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 */
92 if (!dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {
93 Jmsg(jcr, M_FATAL, 0, _("Too many errors trying to mount device %s.\n"),
98 if (job_canceled(jcr)) {
99 Jmsg(jcr, M_FATAL, 0, _("Job %d canceled.\n"), jcr->JobId);
103 if (dev->must_unload()) {
104 Dmsg0(150, "mount_next_volume release=1\n");
105 unload_autochanger(dcr, -1);
108 ask = true; /* ask operator to mount tape */
111 * See if we are asked to swap the Volume from another device
112 * if so, unload the other device here, and attach the
113 * volume to our drive.
116 Dmsg1(100, "Swap unloading %s\n", dev->swap_dev->print_name());
117 if (dev->swap_dev->must_unload()) {
118 unload_dev(dcr, dev->swap_dev);
121 dev->vol->clear_swapping();
122 dev->vol->set_in_use();
123 dev->VolHdr.VolumeName[0] = 0; /* don't yet have right Volume */
125 dev->swap_dev = NULL;
127 if (!is_suitable_volume_mounted()) {
128 bool have_vol = false;
129 /* Do we have a candidate volume? */
131 bstrncpy(VolumeName, dev->vol->vol_name, sizeof(VolumeName));
132 have_vol = dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE);
135 * Get Director's idea of what tape we should have mounted.
139 Dmsg0(200, "Before dir_find_next_appendable_volume.\n");
140 while (!dir_find_next_appendable_volume(dcr)) {
141 Dmsg0(200, "not dir_find_next\n");
142 if (job_canceled(jcr) || !dir_ask_sysop_to_create_appendable_volume(dcr)) {
145 Dmsg0(200, "Again dir_find_next_append...\n");
150 if (job_canceled(jcr)) {
153 Dmsg3(150, "After find_next_append. Vol=%s Slot=%d Parts=%d\n",
154 VolCatInfo.VolCatName, VolCatInfo.Slot, VolCatInfo.VolCatParts);
157 * Get next volume and ready it for append
158 * This code ensures that the device is ready for
159 * writing. We start from the assumption that there
160 * may not be a tape mounted.
162 * If the device is a file, we create the output
163 * file. If it is a tape, we check the volume name
164 * and move the tape to the end of data.
167 if (autoload_device(dcr, 1, NULL) > 0) {
174 Dmsg1(200, "autoload_dev returns %d\n", autochanger);
176 * If we autochanged to correct Volume or (we have not just
177 * released the Volume AND we can automount) we go ahead
178 * and read the label. If there is no tape in the drive,
179 * we will fail, recurse and ask the operator the next time.
181 if (!dev->must_unload() && dev->is_tape() && dev->has_cap(CAP_AUTOMOUNT)) {
182 Dmsg0(150, "(1)Ask=0\n");
183 ask = false; /* don't ask SYSOP this time */
185 /* Don't ask if not removable */
186 if (!dev->is_removable()) {
187 Dmsg0(150, "(2)Ask=0\n");
190 Dmsg2(150, "Ask=%d autochanger=%d\n", ask, autochanger);
191 dev->must_unload(); /* release next time if we "recurse" */
193 if (ask && !dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {
194 Dmsg0(150, "Error return ask_sysop ...\n");
195 goto bail_out; /* error return */
197 if (job_canceled(jcr)) {
200 Dmsg3(150, "want vol=%s devvol=%s dev=%s\n", VolumeName,
201 dev->VolHdr.VolumeName, dev->print_name());
203 if (dev->poll && dev->has_cap(CAP_CLOSEONPOLL)) {
207 /* Ensure the device is open */
208 if (dev->has_cap(CAP_STREAM)) {
209 mode = OPEN_WRITE_ONLY;
211 mode = OPEN_READ_WRITE;
213 /* Try autolabel if enabled */
214 if (dev->open(dcr, mode) < 0) {
215 try_autolabel(false); /* try to create a new volume label */
217 while (dev->open(dcr, mode) < 0) {
218 Dmsg1(150, "open_device failed: ERR=%s\n", dev->bstrerror());
219 if ((dev->is_file() && dev->is_removable()) || dev->is_dvd()) {
221 Dmsg0(150, "call scan_dir_for_vol\n");
223 if (!dev->mount(0)) {
227 if (ok && dev->scan_dir_for_volume(dcr)) {
228 if (dev->open(dcr, mode) >= 0) {
229 break; /* got a valid volume */
232 if (ok && dev->is_dvd()) {
236 if (try_autolabel(false) == try_read_vol) {
237 break; /* created a new volume label */
239 /* If DVD, ignore the error, very often you cannot open the device
240 * (when there is no DVD, or when the one inserted is a wrong one) */
241 if (dev->poll || dev->is_dvd() || dev->is_removable()) {
244 Jmsg(jcr, M_ERROR, 0, _("Could not open device %s: ERR=%s\n"),
245 dev->print_name(), dev->print_errmsg());
251 * Now check the volume label to make sure we have the right tape mounted
255 switch (check_volume_label(ask, autochanger)) {
267 * See if we have a fresh tape or a tape with data.
269 * Note, if the LabelType is PRE_LABEL, it was labeled
270 * but never written. If so, rewrite the label but set as
271 * VOL_LABEL. We rewind and return the label (reconstructed)
272 * in the block so that in the case of a new tape, data can
273 * be appended just after the block label. If we are writing
274 * a second volume, the calling routine will write the label
275 * before writing the overflow block.
277 * If the tape is marked as Recycle, we rewrite the label.
279 recycle = strcmp(dev->VolCatInfo.VolCatStatus, "Recycle") == 0;
280 if (dev->VolHdr.LabelType == PRE_LABEL || recycle) {
281 if (!rewrite_volume_label(dcr, recycle)) {
282 mark_volume_in_error();
287 * OK, at this point, we have a valid Bacula label, but
288 * we need to position to the end of the volume, since we are
289 * just now putting it into append mode.
291 Dmsg0(200, "Device previously written, moving to end of data\n");
292 Jmsg(jcr, M_INFO, 0, _("Volume \"%s\" previously written, moving to end of data.\n"),
295 if (!dev->eod(dcr)) {
296 Jmsg(jcr, M_ERROR, 0, _("Unable to position to end of data on device %s: ERR=%s\n"),
297 dev->print_name(), dev->bstrerror());
298 mark_volume_in_error();
301 if (!is_eod_valid()) {
305 dev->VolCatInfo.VolCatMounts++; /* Update mounts */
306 Dmsg1(150, "update volinfo mounts=%d\n", dev->VolCatInfo.VolCatMounts);
307 if (!dir_update_volume_info(dcr, false, false)) {
311 /* Return an empty block */
312 empty_block(block); /* we used it for reading so set for write */
315 Dmsg1(150, "set APPEND, normal return from mount_next_write_volume. dev=%s\n",
326 int DCR::check_volume_label(bool &ask, bool &autochanger)
328 int vol_label_status;
330 * If we are writing to a stream device, ASSUME the volume label
333 if (dev->has_cap(CAP_STREAM)) {
334 vol_label_status = VOL_OK;
335 create_volume_label(dev, VolumeName, "Default", false /* not DVD */);
336 dev->VolHdr.LabelType = PRE_LABEL;
338 vol_label_status = read_dev_volume_label(this);
340 if (job_canceled(jcr)) {
344 Dmsg2(150, "Want dirVol=%s dirStat=%s\n", VolumeName,
345 VolCatInfo.VolCatStatus);
347 * At this point, dev->VolCatInfo has what is in the drive, if anything,
348 * and dcr->VolCatInfo has what the Director wants.
350 switch (vol_label_status) {
352 Dmsg1(150, "Vol OK name=%s\n", VolumeName);
353 dev->VolCatInfo = VolCatInfo; /* structure assignment */
354 break; /* got a Volume */
356 VOLUME_CAT_INFO dcrVolCatInfo, devVolCatInfo;
357 char saveVolumeName[MAX_NAME_LENGTH];
359 /* If not removable, Volume is broken */
360 if (!dev->is_removable()) {
361 Jmsg(jcr, M_WARNING, 0, _("Volume \"%s\" not on device %s.\n"),
362 VolumeName, dev->print_name());
363 mark_volume_in_error();
364 goto check_next_volume;
367 Dmsg1(150, "Vol NAME Error Name=%s\n", VolumeName);
368 /* If polling and got a previous bad name, ignore it */
369 if (dev->poll && strcmp(dev->BadVolName, dev->VolHdr.VolumeName) == 0) {
371 Dmsg1(200, "Vol Name error supress due to poll. Name=%s\n", VolumeName);
372 goto check_next_volume;
375 * OK, we got a different volume mounted. First save the
376 * requested Volume info (dcr) structure, then query if
377 * this volume is really OK. If not, put back the desired
378 * volume name, mark it not in changer and continue.
380 dcrVolCatInfo = VolCatInfo; /* structure assignment */
381 devVolCatInfo = dev->VolCatInfo; /* structure assignment */
382 /* Check if this is a valid Volume in the pool */
383 bstrncpy(saveVolumeName, VolumeName, sizeof(saveVolumeName));
384 bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
385 if (!dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE)) {
386 POOL_MEM vol_info_msg;
387 pm_strcpy(vol_info_msg, jcr->dir_bsock->msg); /* save error message */
388 /* Restore desired volume name, note device info out of sync */
389 /* This gets the info regardless of the Pool */
390 bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
391 if (autochanger && !dir_get_volume_info(this, GET_VOL_INFO_FOR_READ)) {
393 * If we get here, we know we cannot write on the Volume,
394 * and we know that we cannot read it either, so it
395 * is not in the autochanger.
397 mark_volume_not_inchanger();
399 dev->VolCatInfo = devVolCatInfo; /* structure assignment */
400 bstrncpy(dev->BadVolName, dev->VolHdr.VolumeName, sizeof(dev->BadVolName));
401 Jmsg(jcr, M_WARNING, 0, _("Director wanted Volume \"%s\".\n"
402 " Current Volume \"%s\" not acceptable because:\n"
404 dcrVolCatInfo.VolCatName, dev->VolHdr.VolumeName,
405 vol_info_msg.c_str());
407 /* Restore saved DCR before continuing */
408 bstrncpy(VolumeName, saveVolumeName, sizeof(VolumeName));
409 VolCatInfo = dcrVolCatInfo; /* structure assignment */
410 goto check_next_volume;
413 * This was not the volume we expected, but it is OK with
414 * the Director, so use it.
416 Dmsg1(150, "want new name=%s\n", VolumeName);
417 dev->VolCatInfo = VolCatInfo; /* structure assignment */
418 break; /* got a Volume */
420 * At this point, we assume we have a blank tape mounted.
424 Jmsg(jcr, M_FATAL, 0, "%s", jcr->errmsg);
425 mark_volume_in_error();
426 goto check_bail_out; /* we could not write on DVD */
428 /* Fall through wanted */
430 switch (try_autolabel(true)) {
432 goto check_next_volume;
434 goto check_read_volume;
441 /* NOTE! Fall-through wanted. */
444 Dmsg0(200, "VOL_NO_MEDIA or default.\n");
445 /* Send error message */
448 Dmsg1(200, "Msg suppressed by poll: %s\n", jcr->errmsg);
451 /* Needed, so the medium can be changed */
452 if (dev->requires_mount()) {
455 goto check_next_volume;
460 return check_next_vol;
466 return check_read_vol;
471 bool DCR::is_suitable_volume_mounted()
474 /* Volume mounted? */
475 if (dev->VolHdr.VolumeName[0] == 0 || dev->swap_dev || dev->must_unload()) {
476 return false; /* no */
478 bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
479 return dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE);
485 * Check if the current position on the volume corresponds to
486 * what is in the catalog.
488 bool DCR::is_eod_valid()
491 char ed1[50], ed2[50];
492 if (dev->VolCatInfo.VolCatBytes == dev->part_start + dev->part_size) {
493 Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\""
494 " part=%d size=%s\n"), VolumeName,
495 dev->part, edit_uint64(dev->VolCatInfo.VolCatBytes,ed1));
497 Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on DVD Volume \"%s\" because: "
498 "The sizes do not match! Volume=%s Catalog=%s\n"),
500 edit_uint64(dev->part_start + dev->part_size, ed1),
501 edit_uint64(dev->VolCatInfo.VolCatBytes, ed2));
502 mark_volume_in_error();
505 } else if (dev->is_tape()) {
507 * Check if we are positioned on the tape at the same place
508 * that the database says we should be.
510 if (dev->VolCatInfo.VolCatFiles == dev->get_file()) {
511 Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\" at file=%d.\n"),
512 VolumeName, dev->get_file());
514 Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on tape Volume \"%s\" because:\n"
515 "The number of files mismatch! Volume=%u Catalog=%u\n"),
516 VolumeName, dev->get_file(), dev->VolCatInfo.VolCatFiles);
517 mark_volume_in_error();
520 } else if (dev->is_file()) {
521 char ed1[50], ed2[50];
523 pos = dev->lseek(this, (boffset_t)0, SEEK_END);
524 if (dev->VolCatInfo.VolCatBytes == (uint64_t)pos) {
525 Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\""
526 " size=%s\n"), VolumeName,
527 edit_uint64(dev->VolCatInfo.VolCatBytes, ed1));
529 Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on disk Volume \"%s\" because: "
530 "The sizes do not match! Volume=%s Catalog=%s\n"),
532 edit_uint64(pos, ed1),
533 edit_uint64(dev->VolCatInfo.VolCatBytes, ed2));
534 mark_volume_in_error();
543 * If permitted, we label the device, make sure we can do
544 * it by checking that the VolCatBytes is zero => not labeled,
545 * once the Volume is labeled we don't want to label another
546 * blank tape with the same name. For disk, we go ahead and
547 * label it anyway, because the OS insures that there is only
548 * one Volume with that name.
549 * As noted above, at this point dcr->VolCatInfo has what
550 * the Director wants and dev->VolCatInfo has info on the
551 * previous tape (or nothing).
554 * try_next_vol label failed, look for another volume
555 * try_read_vol labeled volume, now re-read the label
556 * try_error hard error (catalog update)
557 * try_default I couldn't do anything
559 int DCR::try_autolabel(bool opened)
563 if (dev->poll && !dev->is_tape()) {
564 return try_default; /* if polling, don't try to create new labels */
566 /* For a tape require it to be opened and read before labeling */
567 if (!opened && dev->is_tape()) {
570 if (dev->has_cap(CAP_LABEL) && (VolCatInfo.VolCatBytes == 0 ||
571 (!dev->is_tape() && strcmp(VolCatInfo.VolCatStatus,
573 Dmsg0(150, "Create volume label\n");
574 /* Create a new Volume label and write it to the device */
575 if (!write_new_volume_label_to_dev(dcr, VolumeName,
576 pool_name, false, /* no relabel */ false /* defer DVD label */)) {
577 Dmsg0(150, "!write_vol_label\n");
579 mark_volume_in_error();
583 Dmsg0(150, "dir_update_vol_info. Set Append\n");
584 /* Copy Director's info into the device info */
585 dev->VolCatInfo = VolCatInfo; /* structure assignment */
586 if (!dir_update_volume_info(dcr, true, true)) { /* indicate tape labeled */
589 Jmsg(dcr->jcr, M_INFO, 0, _("Labeled new Volume \"%s\" on device %s.\n"),
590 VolumeName, dev->print_name());
591 return try_read_vol; /* read label we just wrote */
593 if (!dev->has_cap(CAP_LABEL) && VolCatInfo.VolCatBytes == 0) {
594 Jmsg(jcr, M_WARNING, 0, _("Device %s not configured to autolabel Volumes.\n"),
597 /* If not removable, Volume is broken */
598 if (!dev->is_removable()) {
599 Jmsg(jcr, M_WARNING, 0, _("Volume \"%s\" not on device %s.\n"),
600 VolumeName, dev->print_name());
601 mark_volume_in_error();
609 * Mark volume in error in catalog
611 void DCR::mark_volume_in_error()
613 Jmsg(jcr, M_INFO, 0, _("Marking Volume \"%s\" in Error in Catalog.\n"),
615 dev->VolCatInfo = VolCatInfo; /* structure assignment */
616 bstrncpy(dev->VolCatInfo.VolCatStatus, "Error", sizeof(dev->VolCatInfo.VolCatStatus));
617 Dmsg0(150, "dir_update_vol_info. Set Error.\n");
618 dir_update_volume_info(this, false, false);
623 * The Volume is not in the correct slot, so mark this
624 * Volume as not being in the Changer.
626 void DCR::mark_volume_not_inchanger()
628 Jmsg(jcr, M_ERROR, 0, _("Autochanger Volume \"%s\" not found in slot %d.\n"
629 " Setting InChanger to zero in catalog.\n"),
630 VolCatInfo.VolCatName, VolCatInfo.Slot);
631 dev->VolCatInfo = VolCatInfo; /* structure assignment */
632 VolCatInfo.InChanger = false;
633 dev->VolCatInfo.InChanger = false;
634 Dmsg0(400, "update vol info in mount\n");
635 dir_update_volume_info(this, true, false); /* set new status */
639 * Either because we are going to hang a new volume, or because
640 * of explicit user request, we release the current volume.
642 void DCR::release_volume()
645 Jmsg0(jcr, M_ERROR, 0, _("Hey!!!!! WroteVol non-zero !!!!!\n"));
646 Dmsg0(190, "Hey!!!!! WroteVol non-zero !!!!!\n");
649 * First erase all memory of the current volume
652 dev->block_num = dev->file = 0;
653 dev->EndBlock = dev->EndFile = 0;
654 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
655 memset(&VolCatInfo, 0, sizeof(VolCatInfo));
657 /* Force re-read of label */
658 dev->clear_labeled();
661 dev->label_type = B_BACULA_LABEL;
664 if (dev->is_open() && (!dev->is_tape() || !dev->has_cap(CAP_ALWAYSOPEN))) {
668 /* If we have not closed the device, then at least rewind the tape */
669 if (dev->is_open()) {
670 dev->offline_or_rewind();
672 Dmsg0(190, "release_volume\n");
676 * If we are reading, we come here at the end of the tape
677 * and see if there are more volumes to be mounted.
679 bool mount_next_read_volume(DCR *dcr)
681 DEVICE *dev = dcr->dev;
683 Dmsg2(90, "NumReadVolumes=%d CurReadVolume=%d\n", jcr->NumReadVolumes, jcr->CurReadVolume);
685 volume_unused(dcr); /* release current volume */
687 * End Of Tape -- mount next Volume (if another specified)
689 if (jcr->NumReadVolumes > 1 && jcr->CurReadVolume < jcr->NumReadVolumes) {
691 if (!acquire_device_for_read(dcr)) {
692 Jmsg2(jcr, M_FATAL, 0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(),
696 return true; /* next volume mounted */
698 Dmsg0(90, "End of Device reached.\n");