2 Bacula® - The Network Backup Solution
4 Copyright (C) 2002-2008 Free Software Foundation Europe e.V.
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
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.
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
23 Bacula® is a registered trademark of John Walker.
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.
30 * Routines for handling mounting tapes for reading and for
33 * Kern Sibbald, August MMII
38 #include "bacula.h" /* pull in global headers */
39 #include "stored.h" /* pull in Storage Deamon headers */
57 * If release is set, we rewind the current volume,
58 * which we no longer want, and ask the user (console)
59 * to mount the next volume.
61 * Continue trying until we get it, and then ensure
62 * that we can write on it.
64 * This routine returns a 0 only if it is REALLY
65 * impossible to get the requested Volume.
68 bool DCR::mount_next_write_volume()
71 bool ask = false, recycle, autochanger;
75 Dmsg2(150, "Enter mount_next_volume(release=%d) dev=%s\n", dev->must_unload(),
78 init_device_wait_timers(dcr);
82 * Attempt to mount the next volume. If something non-fatal goes
83 * wrong, we come back here to re-try (new op messages, re-read
87 Dmsg1(150, "mount_next_vol retry=%d\n", retry);
88 /* Ignore retry if this is poll request */
89 if (!dev->poll && retry++ > 4) {
90 /* Last ditch effort before giving up, force operator to respond */
93 if (!dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {
94 Jmsg(jcr, M_FATAL, 0, _("Too many errors trying to mount device %s.\n"),
96 goto no_lock_bail_out;
100 if (job_canceled(jcr)) {
101 Jmsg(jcr, M_FATAL, 0, _("Job %d canceled.\n"), jcr->JobId);
106 if (dev->must_unload()) {
107 ask = true; /* ask operator to mount tape */
109 do_swapping(true /*writing*/);
111 if (!is_suitable_volume_mounted()) {
112 bool have_vol = false;
113 /* Do we have a candidate volume? */
115 bstrncpy(VolumeName, dev->vol->vol_name, sizeof(VolumeName));
116 have_vol = dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE);
119 * Get Director's idea of what tape we should have mounted.
123 Dmsg0(200, "Before dir_find_next_appendable_volume.\n");
124 while (!dir_find_next_appendable_volume(dcr)) {
125 Dmsg0(200, "not dir_find_next\n");
126 if (job_canceled(jcr)) {
130 if (!dir_ask_sysop_to_create_appendable_volume(dcr)) {
131 goto no_lock_bail_out;
134 Dmsg0(200, "Again dir_find_next_append...\n");
139 if (job_canceled(jcr)) {
142 Dmsg3(150, "After find_next_append. Vol=%s Slot=%d Parts=%d\n",
143 VolCatInfo.VolCatName, VolCatInfo.Slot, VolCatInfo.VolCatParts);
146 * Get next volume and ready it for append
147 * This code ensures that the device is ready for
148 * writing. We start from the assumption that there
149 * may not be a tape mounted.
151 * If the device is a file, we create the output
152 * file. If it is a tape, we check the volume name
153 * and move the tape to the end of data.
156 if (autoload_device(dcr, true/*writing*/, NULL) > 0) {
163 Dmsg1(150, "autoload_dev returns %d\n", autochanger);
165 * If we autochanged to correct Volume or (we have not just
166 * released the Volume AND we can automount) we go ahead
167 * and read the label. If there is no tape in the drive,
168 * we will fail, recurse and ask the operator the next time.
170 if (!dev->must_unload() && dev->is_tape() && dev->has_cap(CAP_AUTOMOUNT)) {
171 Dmsg0(150, "(1)Ask=0\n");
172 ask = false; /* don't ask SYSOP this time */
174 /* Don't ask if not removable */
175 if (!dev->is_removable()) {
176 Dmsg0(150, "(2)Ask=0\n");
179 Dmsg2(150, "Ask=%d autochanger=%d\n", ask, autochanger);
180 dev->must_unload(); /* release next time if we "recurse" */
182 if (ask && !dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {
183 Dmsg0(150, "Error return ask_sysop ...\n");
184 goto bail_out; /* error return */
186 if (job_canceled(jcr)) {
189 Dmsg3(150, "want vol=%s devvol=%s dev=%s\n", VolumeName,
190 dev->VolHdr.VolumeName, dev->print_name());
192 if (dev->poll && dev->has_cap(CAP_CLOSEONPOLL)) {
196 /* Ensure the device is open */
197 if (dev->has_cap(CAP_STREAM)) {
198 mode = OPEN_WRITE_ONLY;
200 mode = OPEN_READ_WRITE;
202 /* Try autolabel if enabled */
203 if (dev->open(dcr, mode) < 0) {
204 try_autolabel(false); /* try to create a new volume label */
206 while (dev->open(dcr, mode) < 0) {
207 Dmsg1(150, "open_device failed: ERR=%s\n", dev->bstrerror());
208 if ((dev->is_file() && dev->is_removable()) || dev->is_dvd()) {
210 Dmsg0(150, "call scan_dir_for_vol\n");
212 if (!dev->mount(0)) {
216 if (ok && dev->scan_dir_for_volume(dcr)) {
217 if (dev->open(dcr, mode) >= 0) {
218 break; /* got a valid volume */
221 if (ok && dev->is_dvd()) {
225 if (try_autolabel(false) == try_read_vol) {
226 break; /* created a new volume label */
228 /* If DVD, ignore the error, very often you cannot open the device
229 * (when there is no DVD, or when the one inserted is a wrong one) */
230 if (dev->poll || dev->is_dvd() || dev->is_removable()) {
233 Jmsg(jcr, M_ERROR, 0, _("Could not open device %s: ERR=%s\n"),
234 dev->print_name(), dev->print_errmsg());
240 * Now check the volume label to make sure we have the right tape mounted
244 switch (check_volume_label(ask, autochanger)) {
256 * See if we have a fresh tape or a tape with data.
258 * Note, if the LabelType is PRE_LABEL, it was labeled
259 * but never written. If so, rewrite the label but set as
260 * VOL_LABEL. We rewind and return the label (reconstructed)
261 * in the block so that in the case of a new tape, data can
262 * be appended just after the block label. If we are writing
263 * a second volume, the calling routine will write the label
264 * before writing the overflow block.
266 * If the tape is marked as Recycle, we rewrite the label.
268 recycle = strcmp(dev->VolCatInfo.VolCatStatus, "Recycle") == 0;
269 if (dev->VolHdr.LabelType == PRE_LABEL || recycle) {
270 if (!rewrite_volume_label(dcr, recycle)) {
271 mark_volume_in_error();
276 * OK, at this point, we have a valid Bacula label, but
277 * we need to position to the end of the volume, since we are
278 * just now putting it into append mode.
280 Dmsg0(200, "Device previously written, moving to end of data\n");
281 Jmsg(jcr, M_INFO, 0, _("Volume \"%s\" previously written, moving to end of data.\n"),
284 if (!dev->eod(dcr)) {
285 Jmsg(jcr, M_ERROR, 0, _("Unable to position to end of data on device %s: ERR=%s\n"),
286 dev->print_name(), dev->bstrerror());
287 mark_volume_in_error();
290 if (!is_eod_valid()) {
294 dev->VolCatInfo.VolCatMounts++; /* Update mounts */
295 Dmsg1(150, "update volinfo mounts=%d\n", dev->VolCatInfo.VolCatMounts);
296 if (!dir_update_volume_info(dcr, false, false)) {
300 /* Return an empty block */
301 empty_block(block); /* we used it for reading so set for write */
304 Dmsg1(150, "set APPEND, normal return from mount_next_write_volume. dev=%s\n",
317 int DCR::check_volume_label(bool &ask, bool &autochanger)
319 int vol_label_status;
321 * If we are writing to a stream device, ASSUME the volume label
324 if (dev->has_cap(CAP_STREAM)) {
325 vol_label_status = VOL_OK;
326 create_volume_label(dev, VolumeName, "Default", false /* not DVD */);
327 dev->VolHdr.LabelType = PRE_LABEL;
329 vol_label_status = read_dev_volume_label(this);
331 if (job_canceled(jcr)) {
335 Dmsg2(150, "Want dirVol=%s dirStat=%s\n", VolumeName,
336 VolCatInfo.VolCatStatus);
338 * At this point, dev->VolCatInfo has what is in the drive, if anything,
339 * and dcr->VolCatInfo has what the Director wants.
341 switch (vol_label_status) {
343 Dmsg1(150, "Vol OK name=%s\n", dev->VolHdr.VolumeName);
344 dev->VolCatInfo = VolCatInfo; /* structure assignment */
345 break; /* got a Volume */
347 VOLUME_CAT_INFO dcrVolCatInfo, devVolCatInfo;
348 char saveVolumeName[MAX_NAME_LENGTH];
350 /* If not removable, Volume is broken */
351 if (!dev->is_removable()) {
352 Jmsg(jcr, M_WARNING, 0, _("Volume \"%s\" not on device %s.\n"),
353 VolumeName, dev->print_name());
354 mark_volume_in_error();
355 goto check_next_volume;
358 Dmsg1(150, "Vol NAME Error Name=%s\n", VolumeName);
359 /* If polling and got a previous bad name, ignore it */
360 if (dev->poll && strcmp(dev->BadVolName, dev->VolHdr.VolumeName) == 0) {
362 Dmsg1(200, "Vol Name error supress due to poll. Name=%s\n", VolumeName);
363 goto check_next_volume;
366 * OK, we got a different volume mounted. First save the
367 * requested Volume info (dcr) structure, then query if
368 * this volume is really OK. If not, put back the desired
369 * volume name, mark it not in changer and continue.
371 dcrVolCatInfo = VolCatInfo; /* structure assignment */
372 devVolCatInfo = dev->VolCatInfo; /* structure assignment */
373 /* Check if this is a valid Volume in the pool */
374 bstrncpy(saveVolumeName, VolumeName, sizeof(saveVolumeName));
375 bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
376 if (!dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE)) {
377 POOL_MEM vol_info_msg;
378 pm_strcpy(vol_info_msg, jcr->dir_bsock->msg); /* save error message */
379 /* Restore desired volume name, note device info out of sync */
380 /* This gets the info regardless of the Pool */
381 bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
382 if (autochanger && !dir_get_volume_info(this, GET_VOL_INFO_FOR_READ)) {
384 * If we get here, we know we cannot write on the Volume,
385 * and we know that we cannot read it either, so it
386 * is not in the autochanger.
388 mark_volume_not_inchanger();
390 dev->VolCatInfo = devVolCatInfo; /* structure assignment */
391 bstrncpy(dev->BadVolName, dev->VolHdr.VolumeName, sizeof(dev->BadVolName));
392 Jmsg(jcr, M_WARNING, 0, _("Director wanted Volume \"%s\".\n"
393 " Current Volume \"%s\" not acceptable because:\n"
395 dcrVolCatInfo.VolCatName, dev->VolHdr.VolumeName,
396 vol_info_msg.c_str());
398 /* Restore saved DCR before continuing */
399 bstrncpy(VolumeName, saveVolumeName, sizeof(VolumeName));
400 VolCatInfo = dcrVolCatInfo; /* structure assignment */
401 goto check_next_volume;
404 * This was not the volume we expected, but it is OK with
405 * the Director, so use it.
407 Dmsg1(150, "Got new Volume name=%s\n", VolumeName);
408 dev->VolCatInfo = VolCatInfo; /* structure assignment */
409 break; /* got a Volume */
411 * At this point, we assume we have a blank tape mounted.
415 Jmsg(jcr, M_FATAL, 0, "%s", jcr->errmsg);
416 mark_volume_in_error();
417 goto check_bail_out; /* we could not write on DVD */
419 /* Fall through wanted */
421 switch (try_autolabel(true)) {
423 goto check_next_volume;
425 goto check_read_volume;
432 /* NOTE! Fall-through wanted. */
435 Dmsg0(200, "VOL_NO_MEDIA or default.\n");
436 /* Send error message */
439 Dmsg1(200, "Msg suppressed by poll: %s\n", jcr->errmsg);
442 /* Needed, so the medium can be changed */
443 if (dev->requires_mount()) {
446 goto check_next_volume;
451 return check_next_vol;
457 return check_read_vol;
462 bool DCR::is_suitable_volume_mounted()
465 /* Volume mounted? */
466 if (dev->VolHdr.VolumeName[0] == 0 || dev->swap_dev || dev->must_unload()) {
467 return false; /* no */
469 bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
470 return dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE);
473 void DCR::do_swapping(bool is_writing)
475 if (dev->must_unload()) {
476 Dmsg1(100, "swapping: unloading %s\n", dev->print_name());
477 unload_autochanger(this, -1);
482 * See if we are asked to swap the Volume from another device
483 * if so, unload the other device here, and attach the
484 * volume to our drive.
487 if (dev->swap_dev->must_unload()) {
489 dev->Slot = dev->vol->get_slot();
491 Dmsg2(100, "Swap unloading slot=%d %s\n", dev->Slot,
492 dev->swap_dev->print_name());
493 unload_dev(this, dev->swap_dev);
497 dev->vol->clear_swapping();
498 dev->vol->set_in_use();
499 dev->VolHdr.VolumeName[0] = 0; /* don't yet have right Volume */
501 dev->swap_dev = NULL;
503 if (dev->must_load()) {
504 Dmsg1(100, "swapping: must load %s\n", dev->print_name());
505 if (autoload_device(this, is_writing, NULL) > 0) {
513 * Check if the current position on the volume corresponds to
514 * what is in the catalog.
516 bool DCR::is_eod_valid()
519 char ed1[50], ed2[50];
520 if (dev->VolCatInfo.VolCatBytes == dev->part_start + dev->part_size) {
521 Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\""
522 " part=%d size=%s\n"), VolumeName,
523 dev->part, edit_uint64(dev->VolCatInfo.VolCatBytes,ed1));
525 Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on DVD Volume \"%s\" because: "
526 "The sizes do not match! Volume=%s Catalog=%s\n"),
528 edit_uint64(dev->part_start + dev->part_size, ed1),
529 edit_uint64(dev->VolCatInfo.VolCatBytes, ed2));
530 mark_volume_in_error();
533 } else if (dev->is_tape()) {
535 * Check if we are positioned on the tape at the same place
536 * that the database says we should be.
538 if (dev->VolCatInfo.VolCatFiles == dev->get_file()) {
539 Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\" at file=%d.\n"),
540 VolumeName, dev->get_file());
542 Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on tape Volume \"%s\" because:\n"
543 "The number of files mismatch! Volume=%u Catalog=%u\n"),
544 VolumeName, dev->get_file(), dev->VolCatInfo.VolCatFiles);
545 mark_volume_in_error();
548 } else if (dev->is_file()) {
549 char ed1[50], ed2[50];
551 pos = dev->lseek(this, (boffset_t)0, SEEK_END);
552 if (dev->VolCatInfo.VolCatBytes == (uint64_t)pos) {
553 Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\""
554 " size=%s\n"), VolumeName,
555 edit_uint64(dev->VolCatInfo.VolCatBytes, ed1));
557 Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on disk Volume \"%s\" because: "
558 "The sizes do not match! Volume=%s Catalog=%s\n"),
560 edit_uint64(pos, ed1),
561 edit_uint64(dev->VolCatInfo.VolCatBytes, ed2));
562 mark_volume_in_error();
571 * If permitted, we label the device, make sure we can do
572 * it by checking that the VolCatBytes is zero => not labeled,
573 * once the Volume is labeled we don't want to label another
574 * blank tape with the same name. For disk, we go ahead and
575 * label it anyway, because the OS insures that there is only
576 * one Volume with that name.
577 * As noted above, at this point dcr->VolCatInfo has what
578 * the Director wants and dev->VolCatInfo has info on the
579 * previous tape (or nothing).
582 * try_next_vol label failed, look for another volume
583 * try_read_vol labeled volume, now re-read the label
584 * try_error hard error (catalog update)
585 * try_default I couldn't do anything
587 int DCR::try_autolabel(bool opened)
591 if (dev->poll && !dev->is_tape()) {
592 return try_default; /* if polling, don't try to create new labels */
594 /* For a tape require it to be opened and read before labeling */
595 if (!opened && dev->is_tape()) {
598 if (dev->has_cap(CAP_LABEL) && (VolCatInfo.VolCatBytes == 0 ||
599 (!dev->is_tape() && strcmp(VolCatInfo.VolCatStatus,
601 Dmsg0(150, "Create volume label\n");
602 /* Create a new Volume label and write it to the device */
603 if (!write_new_volume_label_to_dev(dcr, VolumeName,
604 pool_name, false, /* no relabel */ false /* defer DVD label */)) {
605 Dmsg0(150, "!write_vol_label\n");
607 mark_volume_in_error();
611 Dmsg0(150, "dir_update_vol_info. Set Append\n");
612 /* Copy Director's info into the device info */
613 dev->VolCatInfo = VolCatInfo; /* structure assignment */
614 if (!dir_update_volume_info(dcr, true, true)) { /* indicate tape labeled */
617 Jmsg(dcr->jcr, M_INFO, 0, _("Labeled new Volume \"%s\" on device %s.\n"),
618 VolumeName, dev->print_name());
619 return try_read_vol; /* read label we just wrote */
621 if (!dev->has_cap(CAP_LABEL) && VolCatInfo.VolCatBytes == 0) {
622 Jmsg(jcr, M_WARNING, 0, _("Device %s not configured to autolabel Volumes.\n"),
625 /* If not removable, Volume is broken */
626 if (!dev->is_removable()) {
627 Jmsg(jcr, M_WARNING, 0, _("Volume \"%s\" not on device %s.\n"),
628 VolumeName, dev->print_name());
629 mark_volume_in_error();
637 * Mark volume in error in catalog
639 void DCR::mark_volume_in_error()
641 Jmsg(jcr, M_INFO, 0, _("Marking Volume \"%s\" in Error in Catalog.\n"),
643 dev->VolCatInfo = VolCatInfo; /* structure assignment */
644 bstrncpy(dev->VolCatInfo.VolCatStatus, "Error", sizeof(dev->VolCatInfo.VolCatStatus));
645 Dmsg0(150, "dir_update_vol_info. Set Error.\n");
646 dir_update_volume_info(this, false, false);
648 dev->set_unload(); /* must get a new volume */
652 * The Volume is not in the correct slot, so mark this
653 * Volume as not being in the Changer.
655 void DCR::mark_volume_not_inchanger()
657 Jmsg(jcr, M_ERROR, 0, _("Autochanger Volume \"%s\" not found in slot %d.\n"
658 " Setting InChanger to zero in catalog.\n"),
659 VolCatInfo.VolCatName, VolCatInfo.Slot);
660 dev->VolCatInfo = VolCatInfo; /* structure assignment */
661 VolCatInfo.InChanger = false;
662 dev->VolCatInfo.InChanger = false;
663 Dmsg0(400, "update vol info in mount\n");
664 dir_update_volume_info(this, true, false); /* set new status */
668 * Either because we are going to hang a new volume, or because
669 * of explicit user request, we release the current volume.
671 void DCR::release_volume()
674 Jmsg0(jcr, M_ERROR, 0, _("Hey!!!!! WroteVol non-zero !!!!!\n"));
675 Dmsg0(190, "Hey!!!!! WroteVol non-zero !!!!!\n");
678 * First erase all memory of the current volume
681 dev->block_num = dev->file = 0;
682 dev->EndBlock = dev->EndFile = 0;
683 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
684 // memset(&VolCatInfo, 0, sizeof(VolCatInfo));
686 /* Force re-read of label */
687 dev->clear_labeled();
690 dev->label_type = B_BACULA_LABEL;
693 if (dev->is_open() && (!dev->is_tape() || !dev->has_cap(CAP_ALWAYSOPEN))) {
697 /* If we have not closed the device, then at least rewind the tape */
698 if (dev->is_open()) {
699 dev->offline_or_rewind();
702 Dmsg0(190, "release_volume\n");
706 * If we are reading, we come here at the end of the tape
707 * and see if there are more volumes to be mounted.
709 bool mount_next_read_volume(DCR *dcr)
711 DEVICE *dev = dcr->dev;
713 Dmsg2(90, "NumReadVolumes=%d CurReadVolume=%d\n", jcr->NumReadVolumes, jcr->CurReadVolume);
715 volume_unused(dcr); /* release current volume */
717 * End Of Tape -- mount next Volume (if another specified)
719 if (jcr->NumReadVolumes > 1 && jcr->CurReadVolume < jcr->NumReadVolumes) {
721 if (!acquire_device_for_read(dcr)) {
722 Jmsg2(jcr, M_FATAL, 0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(),
726 return true; /* next volume mounted */
728 Dmsg0(90, "End of Device reached.\n");