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 */
41 static void mark_volume_not_inchanger(DCR *dcr);
42 static int try_autolabel(DCR *dcr, bool opened);
43 static bool is_eod_valid(DCR *dcr);
53 * If release is set, we rewind the current volume,
54 * which we no longer want, and ask the user (console)
55 * to mount the next volume.
57 * Continue trying until we get it, and then ensure
58 * that we can write on it.
60 * This routine returns a 0 only if it is REALLY
61 * impossible to get the requested Volume.
64 bool DCR::mount_next_write_volume()
67 bool ask = false, recycle, autochanger;
72 Dmsg2(150, "Enter mount_next_volume(release=%d) dev=%s\n", unload_device,
75 init_device_wait_timers(dcr);
79 * Attempt to mount the next volume. If something non-fatal goes
80 * wrong, we come back here to re-try (new op messages, re-read
84 Dmsg1(150, "mount_next_vol retry=%d\n", retry);
85 /* Ignore retry if this is poll request */
86 if (!dev->poll && retry++ > 4) {
87 /* Last ditch effort before giving up, force operator to respond */
89 if (!dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {
90 Jmsg(jcr, M_FATAL, 0, _("Too many errors trying to mount device %s.\n"),
95 if (job_canceled(jcr)) {
96 Jmsg(jcr, M_FATAL, 0, _("Job %d canceled.\n"), jcr->JobId);
101 Dmsg0(150, "mount_next_volume release=1\n");
103 unload_autochanger(dcr, -1);
104 unload_device = false;
105 ask = true; /* ask operator to mount tape */
109 * Get Director's idea of what tape we should have mounted.
112 Dmsg0(200, "Before dir_find_next_appendable_volume.\n");
113 while (!dir_find_next_appendable_volume(dcr)) {
114 Dmsg0(200, "not dir_find_next\n");
115 if (!dir_ask_sysop_to_create_appendable_volume(dcr)) {
118 Dmsg0(200, "Again dir_find_next_append...\n");
120 if (job_canceled(jcr)) {
123 Dmsg3(150, "After find_next_append. Vol=%s Slot=%d Parts=%d\n",
124 VolCatInfo.VolCatName, VolCatInfo.Slot, VolCatInfo.VolCatParts);
127 * Get next volume and ready it for append
128 * This code ensures that the device is ready for
129 * writing. We start from the assumption that there
130 * may not be a tape mounted.
132 * If the device is a file, we create the output
133 * file. If it is a tape, we check the volume name
134 * and move the tape to the end of data.
138 dev->vol = swap_dev->vol; /* take its volume */
139 swap_dev->vol = NULL;
140 unload_dev(dcr, swap_dev);
143 if (autoload_device(dcr, 1, NULL) > 0) {
150 Dmsg1(200, "autoload_dev returns %d\n", autochanger);
152 * If we autochanged to correct Volume or (we have not just
153 * released the Volume AND we can automount) we go ahead
154 * and read the label. If there is no tape in the drive,
155 * we will fail, recurse and ask the operator the next time.
157 if (!unload_device && dev->is_tape() && dev->has_cap(CAP_AUTOMOUNT)) {
158 Dmsg0(150, "(1)Ask=0\n");
159 ask = false; /* don't ask SYSOP this time */
161 /* Don't ask if not removable */
162 if (!dev->is_removable()) {
163 Dmsg0(150, "(2)Ask=0\n");
166 Dmsg2(150, "Ask=%d autochanger=%d\n", ask, autochanger);
167 unload_device = true; /* release next time if we "recurse" */
169 if (ask && !dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {
170 Dmsg0(150, "Error return ask_sysop ...\n");
171 goto bail_out; /* error return */
173 if (job_canceled(jcr)) {
176 Dmsg3(150, "want vol=%s devvol=%s dev=%s\n", VolumeName,
177 dev->VolHdr.VolumeName, dev->print_name());
179 if (dev->poll && dev->has_cap(CAP_CLOSEONPOLL)) {
183 /* Ensure the device is open */
184 if (dev->has_cap(CAP_STREAM)) {
185 mode = OPEN_WRITE_ONLY;
187 mode = OPEN_READ_WRITE;
189 /* Try autolabel if enabled */
190 if (dev->open(dcr, mode) < 0) {
191 try_autolabel(dcr, false); /* try to create a new volume label */
193 while (dev->open(dcr, mode) < 0) {
194 Dmsg1(150, "open_device failed: ERR=%s\n", dev->bstrerror());
195 if ((dev->is_file() && dev->is_removable()) || dev->is_dvd()) {
197 Dmsg0(150, "call scan_dir_for_vol\n");
199 if (!dev->mount(0)) {
203 if (ok && dev->scan_dir_for_volume(dcr)) {
204 if (dev->open(dcr, mode) >= 0) {
205 break; /* got a valid volume */
208 if (ok && dev->is_dvd()) {
212 if (try_autolabel(dcr, false) == try_read_vol) {
213 break; /* created a new volume label */
215 /* If DVD, ignore the error, very often you cannot open the device
216 * (when there is no DVD, or when the one inserted is a wrong one) */
217 if (dev->poll || dev->is_dvd() || dev->is_removable()) {
220 Jmsg(jcr, M_ERROR, 0, _("Could not open device %s: ERR=%s\n"),
221 dev->print_name(), dev->print_errmsg());
227 * Now make sure we have the right tape mounted
231 * If we are writing to a stream device, ASSUME the volume label
234 if (dev->has_cap(CAP_STREAM)) {
235 vol_label_status = VOL_OK;
236 create_volume_label(dev, VolumeName, "Default", false /* not DVD */);
237 dev->VolHdr.LabelType = PRE_LABEL;
239 vol_label_status = read_dev_volume_label(dcr);
241 if (job_canceled(jcr)) {
245 Dmsg2(150, "Want dirVol=%s dirStat=%s\n", VolumeName,
246 VolCatInfo.VolCatStatus);
248 * At this point, dev->VolCatInfo has what is in the drive, if anything,
249 * and dcr->VolCatInfo has what the Director wants.
251 switch (vol_label_status) {
253 Dmsg1(150, "Vol OK name=%s\n", VolumeName);
254 dev->VolCatInfo = VolCatInfo; /* structure assignment */
255 recycle = strcmp(dev->VolCatInfo.VolCatStatus, "Recycle") == 0;
256 break; /* got a Volume */
258 VOLUME_CAT_INFO dcrVolCatInfo, devVolCatInfo;
259 char VolumeName[MAX_NAME_LENGTH];
261 /* If not removable, Volume is broken */
262 if (!dev->is_removable()) {
263 Jmsg(jcr, M_WARNING, 0, _("Volume \"%s\" not on device %s.\n"),
264 VolumeName, dev->print_name());
265 dcr->mark_volume_in_error();
269 Dmsg1(150, "Vol NAME Error Name=%s\n", VolumeName);
270 /* If polling and got a previous bad name, ignore it */
271 if (dev->poll && strcmp(dev->BadVolName, dev->VolHdr.VolumeName) == 0) {
273 Dmsg1(200, "Vol Name error supress due to poll. Name=%s\n", VolumeName);
277 * OK, we got a different volume mounted. First save the
278 * requested Volume info (dcr) structure, then query if
279 * this volume is really OK. If not, put back the desired
280 * volume name, mark it not in changer and continue.
282 dcrVolCatInfo = VolCatInfo; /* structure assignment */
283 devVolCatInfo = dev->VolCatInfo; /* structure assignment */
284 /* Check if this is a valid Volume in the pool */
285 bstrncpy(VolumeName, VolumeName, sizeof(VolumeName));
286 bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
287 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
288 POOL_MEM vol_info_msg;
289 pm_strcpy(vol_info_msg, jcr->dir_bsock->msg); /* save error message */
290 /* Restore desired volume name, note device info out of sync */
291 /* This gets the info regardless of the Pool */
292 bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
293 if (autochanger && !dir_get_volume_info(dcr, GET_VOL_INFO_FOR_READ)) {
295 * If we get here, we know we cannot write on the Volume,
296 * and we know that we cannot read it either, so it
297 * is not in the autochanger.
299 mark_volume_not_inchanger(dcr);
301 dev->VolCatInfo = devVolCatInfo; /* structure assignment */
302 bstrncpy(dev->BadVolName, dev->VolHdr.VolumeName, sizeof(dev->BadVolName));
303 Jmsg(jcr, M_WARNING, 0, _("Director wanted Volume \"%s\".\n"
304 " Current Volume \"%s\" not acceptable because:\n"
306 dcrVolCatInfo.VolCatName, dev->VolHdr.VolumeName,
307 vol_info_msg.c_str());
309 /* Restore saved DCR before continuing */
310 bstrncpy(VolumeName, VolumeName, sizeof(VolumeName));
311 VolCatInfo = dcrVolCatInfo; /* structure assignment */
315 * This was not the volume we expected, but it is OK with
316 * the Director, so use it.
318 Dmsg1(150, "want new name=%s\n", VolumeName);
319 dev->VolCatInfo = VolCatInfo; /* structure assignment */
320 recycle = strcmp(dev->VolCatInfo.VolCatStatus, "Recycle") == 0;
321 break; /* got a Volume */
323 * At this point, we assume we have a blank tape mounted.
327 Jmsg(jcr, M_FATAL, 0, "%s", jcr->errmsg);
328 dcr->mark_volume_in_error();
329 goto bail_out; /* we could not write on DVD */
331 /* Fall through wanted */
333 switch (try_autolabel(dcr, true)) {
344 /* NOTE! Fall-through wanted. */
347 Dmsg0(200, "VOL_NO_MEDIA or default.\n");
348 /* Send error message */
351 Dmsg1(200, "Msg suppressed by poll: %s\n", jcr->errmsg);
354 /* Needed, so the medium can be changed */
355 if (dev->requires_mount()) {
362 * See if we have a fresh tape or a tape with data.
364 * Note, if the LabelType is PRE_LABEL, it was labeled
365 * but never written. If so, rewrite the label but set as
366 * VOL_LABEL. We rewind and return the label (reconstructed)
367 * in the block so that in the case of a new tape, data can
368 * be appended just after the block label. If we are writing
369 * a second volume, the calling routine will write the label
370 * before writing the overflow block.
372 * If the tape is marked as Recycle, we rewrite the label.
374 if (dev->VolHdr.LabelType == PRE_LABEL || recycle) {
375 if (!rewrite_volume_label(dcr, recycle)) {
376 dcr->mark_volume_in_error();
381 * OK, at this point, we have a valid Bacula label, but
382 * we need to position to the end of the volume, since we are
383 * just now putting it into append mode.
385 Dmsg0(200, "Device previously written, moving to end of data\n");
386 Jmsg(jcr, M_INFO, 0, _("Volume \"%s\" previously written, moving to end of data.\n"),
389 if (!dev->eod(dcr)) {
390 Jmsg(jcr, M_ERROR, 0, _("Unable to position to end of data on device %s: ERR=%s\n"),
391 dev->print_name(), dev->bstrerror());
392 dcr->mark_volume_in_error();
395 if (!is_eod_valid(dcr)) {
399 dev->VolCatInfo.VolCatMounts++; /* Update mounts */
400 Dmsg1(150, "update volinfo mounts=%d\n", dev->VolCatInfo.VolCatMounts);
401 if (!dir_update_volume_info(dcr, false, false)) {
405 /* Return an empty block */
406 empty_block(block); /* we used it for reading so set for write */
409 Dmsg1(150, "set APPEND, normal return from mount_next_write_volume. dev=%s\n",
422 * Check if the current position on the volume corresponds to
423 * what is in the catalog.
425 static bool is_eod_valid(DCR *dcr)
427 DEVICE *dev = dcr->dev;
431 char ed1[50], ed2[50];
432 if (dev->VolCatInfo.VolCatBytes == dev->part_start + dev->part_size) {
433 Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\""
434 " part=%d size=%s\n"), dcr->VolumeName,
435 dev->part, edit_uint64(dev->VolCatInfo.VolCatBytes,ed1));
437 Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on DVD Volume \"%s\" because: "
438 "The sizes do not match! Volume=%s Catalog=%s\n"),
440 edit_uint64(dev->part_start + dev->part_size, ed1),
441 edit_uint64(dev->VolCatInfo.VolCatBytes, ed2));
442 dcr->mark_volume_in_error();
445 } else if (dev->is_tape()) {
447 * Check if we are positioned on the tape at the same place
448 * that the database says we should be.
450 if (dev->VolCatInfo.VolCatFiles == dev->get_file()) {
451 Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\" at file=%d.\n"),
452 dcr->VolumeName, dev->get_file());
454 Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on tape Volume \"%s\" because:\n"
455 "The number of files mismatch! Volume=%u Catalog=%u\n"),
456 dcr->VolumeName, dev->get_file(), dev->VolCatInfo.VolCatFiles);
457 dcr->mark_volume_in_error();
460 } else if (dev->is_file()) {
461 char ed1[50], ed2[50];
463 pos = dev->lseek(dcr, (boffset_t)0, SEEK_END);
464 if (dev->VolCatInfo.VolCatBytes == (uint64_t)pos) {
465 Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\""
466 " size=%s\n"), dcr->VolumeName,
467 edit_uint64(dev->VolCatInfo.VolCatBytes, ed1));
469 Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on disk Volume \"%s\" because: "
470 "The sizes do not match! Volume=%s Catalog=%s\n"),
472 edit_uint64(pos, ed1),
473 edit_uint64(dev->VolCatInfo.VolCatBytes, ed2));
474 dcr->mark_volume_in_error();
483 * If permitted, we label the device, make sure we can do
484 * it by checking that the VolCatBytes is zero => not labeled,
485 * once the Volume is labeled we don't want to label another
486 * blank tape with the same name. For disk, we go ahead and
487 * label it anyway, because the OS insures that there is only
488 * one Volume with that name.
489 * As noted above, at this point dcr->VolCatInfo has what
490 * the Director wants and dev->VolCatInfo has info on the
491 * previous tape (or nothing).
494 * try_next_vol label failed, look for another volume
495 * try_read_vol labeled volume, now re-read the label
496 * try_error hard error (catalog update)
497 * try_default I couldn't do anything
499 static int try_autolabel(DCR *dcr, bool opened)
501 DEVICE *dev = dcr->dev;
503 if (dev->poll && !dev->is_tape()) {
504 return try_default; /* if polling, don't try to create new labels */
506 /* For a tape require it to be opened and read before labeling */
507 if (!opened && dev->is_tape()) {
510 if (dev->has_cap(CAP_LABEL) && (dcr->VolCatInfo.VolCatBytes == 0 ||
511 (!dev->is_tape() && strcmp(dcr->VolCatInfo.VolCatStatus,
513 Dmsg0(150, "Create volume label\n");
514 /* Create a new Volume label and write it to the device */
515 if (!write_new_volume_label_to_dev(dcr, dcr->VolumeName,
516 dcr->pool_name, false, /* no relabel */ false /* defer DVD label */)) {
517 Dmsg0(150, "!write_vol_label\n");
519 dcr->mark_volume_in_error();
523 Dmsg0(150, "dir_update_vol_info. Set Append\n");
524 /* Copy Director's info into the device info */
525 dev->VolCatInfo = dcr->VolCatInfo; /* structure assignment */
526 if (!dir_update_volume_info(dcr, true, true)) { /* indicate tape labeled */
529 Jmsg(dcr->jcr, M_INFO, 0, _("Labeled new Volume \"%s\" on device %s.\n"),
530 dcr->VolumeName, dev->print_name());
531 return try_read_vol; /* read label we just wrote */
533 if (!dev->has_cap(CAP_LABEL) && dcr->VolCatInfo.VolCatBytes == 0) {
534 Jmsg(dcr->jcr, M_WARNING, 0, _("Device %s not configured to autolabel Volumes.\n"),
537 /* If not removable, Volume is broken */
538 if (!dev->is_removable()) {
539 Jmsg(dcr->jcr, M_WARNING, 0, _("Volume \"%s\" not on device %s.\n"),
540 dcr->VolumeName, dev->print_name());
541 dcr->mark_volume_in_error();
549 * Mark volume in error in catalog
551 void DCR::mark_volume_in_error()
553 Jmsg(jcr, M_INFO, 0, _("Marking Volume \"%s\" in Error in Catalog.\n"),
555 dev->VolCatInfo = VolCatInfo; /* structure assignment */
556 bstrncpy(dev->VolCatInfo.VolCatStatus, "Error", sizeof(dev->VolCatInfo.VolCatStatus));
557 Dmsg0(150, "dir_update_vol_info. Set Error.\n");
558 dir_update_volume_info(this, false, false);
563 * The Volume is not in the correct slot, so mark this
564 * Volume as not being in the Changer.
566 static void mark_volume_not_inchanger(DCR *dcr)
569 DEVICE *dev = dcr->dev;
570 Jmsg(jcr, M_ERROR, 0, _("Autochanger Volume \"%s\" not found in slot %d.\n"
571 " Setting InChanger to zero in catalog.\n"),
572 dcr->VolCatInfo.VolCatName, dcr->VolCatInfo.Slot);
573 dev->VolCatInfo = dcr->VolCatInfo; /* structure assignment */
574 dcr->VolCatInfo.InChanger = false;
575 dev->VolCatInfo.InChanger = false;
576 Dmsg0(400, "update vol info in mount\n");
577 dir_update_volume_info(dcr, true, false); /* set new status */
581 * Either because we are going to hang a new volume, or because
582 * of explicit user request, we release the current volume.
584 void release_volume(DCR *dcr)
587 DEVICE *dev = dcr->dev;
589 Jmsg0(jcr, M_ERROR, 0, _("Hey!!!!! WroteVol non-zero !!!!!\n"));
590 Dmsg0(190, "Hey!!!!! WroteVol non-zero !!!!!\n");
593 * First erase all memory of the current volume
596 dev->block_num = dev->file = 0;
597 dev->EndBlock = dev->EndFile = 0;
598 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
599 // memset(&dcr->VolCatInfo, 0, sizeof(dcr->VolCatInfo));
601 /* Force re-read of label */
602 dev->clear_labeled();
605 dev->label_type = B_BACULA_LABEL;
606 // dcr->VolumeName[0] = 0;
608 if (dev->is_open() && (!dev->is_tape() || !dev->has_cap(CAP_ALWAYSOPEN))) {
612 /* If we have not closed the device, then at least rewind the tape */
613 if (dev->is_open()) {
614 dev->offline_or_rewind();
616 Dmsg0(190, "release_volume\n");
620 * If we are reading, we come here at the end of the tape
621 * and see if there are more volumes to be mounted.
623 bool mount_next_read_volume(DCR *dcr)
625 DEVICE *dev = dcr->dev;
627 Dmsg2(90, "NumReadVolumes=%d CurReadVolume=%d\n", jcr->NumReadVolumes, jcr->CurReadVolume);
629 volume_unused(dcr); /* release current volume */
631 * End Of Tape -- mount next Volume (if another specified)
633 if (jcr->NumReadVolumes > 1 && jcr->CurReadVolume < jcr->NumReadVolumes) {
635 if (!acquire_device_for_read(dcr)) {
636 Jmsg2(jcr, M_FATAL, 0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(),
640 return true; /* next volume mounted */
642 Dmsg0(90, "End of Device reached.\n");