2 Bacula® - The Network Backup Solution
4 Copyright (C) 2002-2009 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 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.
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;
76 Dmsg2(150, "Enter mount_next_volume(release=%d) dev=%s\n", dev->must_unload(),
79 init_device_wait_timers(dcr);
83 * Attempt to mount the next volume. If something non-fatal goes
84 * wrong, we come back here to re-try (new op messages, re-read
88 Dmsg1(150, "mount_next_vol retry=%d\n", retry);
89 /* Ignore retry if this is poll request */
90 if (!dev->poll && retry++ > 4) {
91 /* Last ditch effort before giving up, force operator to respond */
94 if (!dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {
95 Jmsg(jcr, M_FATAL, 0, _("Too many errors trying to mount device %s.\n"),
97 goto no_lock_bail_out;
100 Dmsg1(150, "Continue after dir_ask_sysop_to_mount. must_load=%d\n", dev->must_load());
102 if (job_canceled(jcr)) {
103 Jmsg(jcr, M_FATAL, 0, _("Job %d canceled.\n"), jcr->JobId);
112 if (dev->must_unload()) {
113 ask = true; /* ask operator to mount tape */
114 do_find = true; /* re-find a volume after unload */
117 do_swapping(true /*is_writing*/);
118 do_load(true /*is_writing*/);
120 if (do_find && !find_a_volume()) {
121 goto no_lock_bail_out;
124 if (job_canceled(jcr)) {
127 Dmsg3(150, "After find_next_append. Vol=%s Slot=%d Parts=%d\n",
128 VolCatInfo.VolCatName, VolCatInfo.Slot, VolCatInfo.VolCatParts);
131 * Get next volume and ready it for append
132 * This code ensures that the device is ready for
133 * writing. We start from the assumption that there
134 * may not be a tape mounted.
136 * If the device is a file, we create the output
137 * file. If it is a tape, we check the volume name
138 * and move the tape to the end of data.
141 if (autoload_device(dcr, true/*writing*/, NULL) > 0) {
148 do_find = true; /* do find_a_volume if we retry */
150 Dmsg1(150, "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 (!dev->must_unload() && dev->is_tape() && dev->has_cap(CAP_AUTOMOUNT)) {
158 Dmsg0(250, "(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(250, "(2)Ask=0\n");
166 Dmsg2(250, "Ask=%d autochanger=%d\n", ask, autochanger);
170 if (!dir_ask_sysop_to_mount_volume(dcr, ST_APPEND)) {
171 Dmsg0(150, "Error return ask_sysop ...\n");
172 goto no_lock_bail_out;
176 if (job_canceled(jcr)) {
179 Dmsg3(150, "want vol=%s devvol=%s dev=%s\n", VolumeName,
180 dev->VolHdr.VolumeName, dev->print_name());
182 if (dev->poll && dev->has_cap(CAP_CLOSEONPOLL)) {
187 /* Ensure the device is open */
188 if (dev->has_cap(CAP_STREAM)) {
189 mode = OPEN_WRITE_ONLY;
191 mode = OPEN_READ_WRITE;
193 /* Try autolabel if enabled */
194 if (dev->open(dcr, mode) < 0) {
195 try_autolabel(false); /* try to create a new volume label */
197 while (dev->open(dcr, mode) < 0) {
198 Dmsg1(150, "open_device failed: ERR=%s\n", dev->bstrerror());
199 if ((dev->is_file() && dev->is_removable()) || dev->is_dvd()) {
201 Dmsg0(150, "call scan_dir_for_vol\n");
203 if (!dev->mount(0)) {
207 if (ok && dev->scan_dir_for_volume(dcr)) {
208 if (dev->open(dcr, mode) >= 0) {
209 break; /* got a valid volume */
212 if (ok && dev->is_dvd()) {
216 if (try_autolabel(false) == try_read_vol) {
217 break; /* created a new volume label */
219 Dmsg0(50, "set_unload\n");
220 dev->set_unload(); /* force ask sysop */
222 Dmsg0(150, "goto mount_next_vol\n");
227 * Now check the volume label to make sure we have the right tape mounted
230 switch (check_volume_label(ask, autochanger)) {
232 Dmsg0(50, "set_unload\n");
233 dev->set_unload(); /* want a different Volume */
234 Dmsg0(150, "goto mount_next_vol\n");
245 * See if we have a fresh tape or a tape with data.
247 * Note, if the LabelType is PRE_LABEL, it was labeled
248 * but never written. If so, rewrite the label but set as
249 * VOL_LABEL. We rewind and return the label (reconstructed)
250 * in the block so that in the case of a new tape, data can
251 * be appended just after the block label. If we are writing
252 * a second volume, the calling routine will write the label
253 * before writing the overflow block.
255 * If the tape is marked as Recycle, we rewrite the label.
257 recycle = strcmp(dev->VolCatInfo.VolCatStatus, "Recycle") == 0;
258 if (dev->VolHdr.LabelType == PRE_LABEL || recycle) {
259 if (!rewrite_volume_label(dcr, recycle)) {
260 mark_volume_in_error();
265 * OK, at this point, we have a valid Bacula label, but
266 * we need to position to the end of the volume, since we are
267 * just now putting it into append mode.
269 Dmsg0(200, "Device previously written, moving to end of data\n");
270 Jmsg(jcr, M_INFO, 0, _("Volume \"%s\" previously written, moving to end of data.\n"),
273 if (!dev->eod(dcr)) {
274 Jmsg(jcr, M_ERROR, 0, _("Unable to position to end of data on device %s: ERR=%s\n"),
275 dev->print_name(), dev->bstrerror());
276 mark_volume_in_error();
279 if (!is_eod_valid()) {
280 Dmsg0(150, "goto mount_next_vol\n");
284 dev->VolCatInfo.VolCatMounts++; /* Update mounts */
285 Dmsg1(150, "update volinfo mounts=%d\n", dev->VolCatInfo.VolCatMounts);
286 if (!dir_update_volume_info(dcr, false, false)) {
290 /* Return an empty block */
291 empty_block(block); /* we used it for reading so set for write */
294 Dmsg1(150, "set APPEND, normal return from mount_next_write_volume. dev=%s\n",
308 * This routine is meant to be called once the first pass
309 * to ensure that we have a candidate volume to mount.
310 * Otherwise, we ask the sysop to created one.
312 bool DCR::find_a_volume()
315 if (!is_suitable_volume_mounted()) {
316 bool have_vol = false;
317 /* Do we have a candidate volume? */
319 bstrncpy(VolumeName, dev->vol->vol_name, sizeof(VolumeName));
320 have_vol = dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE);
323 * Get Director's idea of what tape we should have mounted.
327 Dmsg0(200, "Before dir_find_next_appendable_volume.\n");
328 while (!dir_find_next_appendable_volume(dcr)) {
329 Dmsg0(200, "not dir_find_next\n");
330 if (job_canceled(jcr)) {
335 if (!dir_ask_sysop_to_create_appendable_volume(dcr)) {
339 Dmsg0(150, "Again dir_find_next_append...\n");
346 int DCR::check_volume_label(bool &ask, bool &autochanger)
348 int vol_label_status;
350 * If we are writing to a stream device, ASSUME the volume label
353 if (dev->has_cap(CAP_STREAM)) {
354 vol_label_status = VOL_OK;
355 create_volume_label(dev, VolumeName, "Default", false /* not DVD */);
356 dev->VolHdr.LabelType = PRE_LABEL;
358 vol_label_status = read_dev_volume_label(this);
360 if (job_canceled(jcr)) {
364 Dmsg2(150, "Want dirVol=%s dirStat=%s\n", VolumeName,
365 VolCatInfo.VolCatStatus);
367 * At this point, dev->VolCatInfo has what is in the drive, if anything,
368 * and dcr->VolCatInfo has what the Director wants.
370 switch (vol_label_status) {
372 Dmsg1(150, "Vol OK name=%s\n", dev->VolHdr.VolumeName);
373 dev->VolCatInfo = VolCatInfo; /* structure assignment */
374 break; /* got a Volume */
376 VOLUME_CAT_INFO dcrVolCatInfo, devVolCatInfo;
377 char saveVolumeName[MAX_NAME_LENGTH];
379 Dmsg2(150, "Vol NAME Error Have=%s, want=%s\n", dev->VolHdr.VolumeName, VolumeName);
380 if (dev->is_volume_to_unload()) {
382 goto check_next_volume;
385 /* If not removable, Volume is broken */
386 if (!dev->is_removable()) {
387 Jmsg(jcr, M_WARNING, 0, _("Volume \"%s\" not on device %s.\n"),
388 VolumeName, dev->print_name());
389 mark_volume_in_error();
390 goto check_next_volume;
394 * OK, we got a different volume mounted. First save the
395 * requested Volume info (dcr) structure, then query if
396 * this volume is really OK. If not, put back the desired
397 * volume name, mark it not in changer and continue.
399 dcrVolCatInfo = VolCatInfo; /* structure assignment */
400 devVolCatInfo = dev->VolCatInfo; /* structure assignment */
401 /* Check if this is a valid Volume in the pool */
402 bstrncpy(saveVolumeName, VolumeName, sizeof(saveVolumeName));
403 bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
404 if (!dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE)) {
405 POOL_MEM vol_info_msg;
406 pm_strcpy(vol_info_msg, jcr->dir_bsock->msg); /* save error message */
407 /* Restore desired volume name, note device info out of sync */
408 /* This gets the info regardless of the Pool */
409 bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
410 if (autochanger && !dir_get_volume_info(this, GET_VOL_INFO_FOR_READ)) {
412 * If we get here, we know we cannot write on the Volume,
413 * and we know that we cannot read it either, so it
414 * is not in the autochanger.
416 mark_volume_not_inchanger();
418 dev->VolCatInfo = devVolCatInfo; /* structure assignment */
419 dev->set_unload(); /* unload this volume */
420 Jmsg(jcr, M_WARNING, 0, _("Director wanted Volume \"%s\".\n"
421 " Current Volume \"%s\" not acceptable because:\n"
423 dcrVolCatInfo.VolCatName, dev->VolHdr.VolumeName,
424 vol_info_msg.c_str());
426 /* Restore saved DCR before continuing */
427 bstrncpy(VolumeName, saveVolumeName, sizeof(VolumeName));
428 VolCatInfo = dcrVolCatInfo; /* structure assignment */
429 goto check_next_volume;
432 * This was not the volume we expected, but it is OK with
433 * the Director, so use it.
435 Dmsg1(150, "Got new Volume name=%s\n", VolumeName);
436 dev->VolCatInfo = VolCatInfo; /* structure assignment */
437 Dmsg1(100, "Call reserve_volume=%s\n", dev->VolHdr.VolumeName);
438 if (reserve_volume(this, dev->VolHdr.VolumeName) == NULL) {
439 Jmsg2(jcr, M_WARNING, 0, _("Could not reserve volume %s on %s\n"),
440 dev->VolHdr.VolumeName, dev->print_name());
442 goto check_next_volume;
444 break; /* got a Volume */
446 * At this point, we assume we have a blank tape mounted.
450 Jmsg(jcr, M_FATAL, 0, "%s", jcr->errmsg);
451 mark_volume_in_error();
452 goto check_bail_out; /* we could not write on DVD */
454 /* Fall through wanted */
456 switch (try_autolabel(true)) {
458 goto check_next_volume;
460 goto check_read_volume;
466 /* NOTE! Fall-through wanted. */
469 Dmsg0(200, "VOL_NO_MEDIA or default.\n");
470 /* Send error message */
473 Dmsg1(200, "Msg suppressed by poll: %s\n", jcr->errmsg);
476 /* Needed, so the medium can be changed */
477 if (dev->requires_mount()) {
481 goto check_next_volume;
486 return check_next_vol;
492 return check_read_vol;
497 bool DCR::is_suitable_volume_mounted()
499 /* Volume mounted? */
500 if (dev->VolHdr.VolumeName[0] == 0 || dev->swap_dev || dev->must_unload()) {
501 return false; /* no */
503 bstrncpy(VolumeName, dev->VolHdr.VolumeName, sizeof(VolumeName));
504 return dir_get_volume_info(this, GET_VOL_INFO_FOR_WRITE);
507 bool DCR::do_unload()
509 if (dev->must_unload()) {
510 Dmsg1(100, "must_unload release %s\n", dev->print_name());
516 bool DCR::do_load(bool is_writing)
518 if (dev->must_load()) {
519 Dmsg1(100, "Must load %s\n", dev->print_name());
520 if (autoload_device(this, is_writing, NULL) > 0) {
529 void DCR::do_swapping(bool is_writing)
532 * See if we are asked to swap the Volume from another device
533 * if so, unload the other device here, and attach the
534 * volume to our drive.
537 if (dev->swap_dev->must_unload()) {
539 dev->swap_dev->set_slot(dev->vol->get_slot());
541 Dmsg2(100, "Swap unloading slot=%d %s\n", dev->swap_dev->get_slot(),
542 dev->swap_dev->print_name());
543 unload_dev(this, dev->swap_dev);
546 dev->vol->clear_swapping();
547 Dmsg1(100, "=== set in_use vol=%s\n", dev->vol->vol_name);
548 dev->vol->set_in_use();
549 dev->VolHdr.VolumeName[0] = 0; /* don't yet have right Volume */
551 Dmsg1(100, "No vol on dev=%s\n", dev->print_name());
553 if (dev->swap_dev->vol) {
554 Dmsg2(100, "Vol=%s on dev=%s\n", dev->swap_dev->vol->vol_name,
555 dev->swap_dev->print_name());
557 dev->swap_dev = NULL;
563 * Check if the current position on the volume corresponds to
564 * what is in the catalog.
566 bool DCR::is_eod_valid()
569 char ed1[50], ed2[50];
570 if (dev->VolCatInfo.VolCatBytes == dev->part_start + dev->part_size) {
571 Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\""
572 " part=%d size=%s\n"), VolumeName,
573 dev->part, edit_uint64(dev->VolCatInfo.VolCatBytes,ed1));
575 Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on DVD Volume \"%s\" because: "
576 "The sizes do not match! Volume=%s Catalog=%s\n"),
578 edit_uint64(dev->part_start + dev->part_size, ed1),
579 edit_uint64(dev->VolCatInfo.VolCatBytes, ed2));
580 mark_volume_in_error();
583 } else if (dev->is_tape()) {
585 * Check if we are positioned on the tape at the same place
586 * that the database says we should be.
588 if (dev->VolCatInfo.VolCatFiles == dev->get_file()) {
589 Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\" at file=%d.\n"),
590 VolumeName, dev->get_file());
592 Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on tape Volume \"%s\" because:\n"
593 "The number of files mismatch! Volume=%u Catalog=%u\n"),
594 VolumeName, dev->get_file(), dev->VolCatInfo.VolCatFiles);
595 mark_volume_in_error();
598 } else if (dev->is_file()) {
599 char ed1[50], ed2[50];
601 pos = dev->lseek(this, (boffset_t)0, SEEK_END);
602 if (dev->VolCatInfo.VolCatBytes == (uint64_t)pos) {
603 Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\""
604 " size=%s\n"), VolumeName,
605 edit_uint64(dev->VolCatInfo.VolCatBytes, ed1));
607 Jmsg(jcr, M_ERROR, 0, _("Bacula cannot write on disk Volume \"%s\" because: "
608 "The sizes do not match! Volume=%s Catalog=%s\n"),
610 edit_uint64(pos, ed1),
611 edit_uint64(dev->VolCatInfo.VolCatBytes, ed2));
612 mark_volume_in_error();
621 * If permitted, we label the device, make sure we can do
622 * it by checking that the VolCatBytes is zero => not labeled,
623 * once the Volume is labeled we don't want to label another
624 * blank tape with the same name. For disk, we go ahead and
625 * label it anyway, because the OS insures that there is only
626 * one Volume with that name.
627 * As noted above, at this point dcr->VolCatInfo has what
628 * the Director wants and dev->VolCatInfo has info on the
629 * previous tape (or nothing).
632 * try_next_vol label failed, look for another volume
633 * try_read_vol labeled volume, now re-read the label
634 * try_error hard error (catalog update)
635 * try_default I couldn't do anything
637 int DCR::try_autolabel(bool opened)
641 if (dev->poll && !dev->is_tape()) {
642 return try_default; /* if polling, don't try to create new labels */
644 /* For a tape require it to be opened and read before labeling */
645 if (!opened && dev->is_tape()) {
648 if (dev->has_cap(CAP_LABEL) && (VolCatInfo.VolCatBytes == 0 ||
649 (!dev->is_tape() && strcmp(VolCatInfo.VolCatStatus,
651 Dmsg0(150, "Create volume label\n");
652 /* Create a new Volume label and write it to the device */
653 if (!write_new_volume_label_to_dev(dcr, VolumeName,
654 pool_name, false, /* no relabel */ false /* defer DVD label */)) {
655 Dmsg2(150, "write_vol_label failed. vol=%s, pool=%s\n",
656 VolumeName, pool_name);
658 mark_volume_in_error();
662 Dmsg0(150, "dir_update_vol_info. Set Append\n");
663 /* Copy Director's info into the device info */
664 dev->VolCatInfo = VolCatInfo; /* structure assignment */
665 if (!dir_update_volume_info(dcr, true, true)) { /* indicate tape labeled */
668 Jmsg(dcr->jcr, M_INFO, 0, _("Labeled new Volume \"%s\" on device %s.\n"),
669 VolumeName, dev->print_name());
670 return try_read_vol; /* read label we just wrote */
672 if (!dev->has_cap(CAP_LABEL) && VolCatInfo.VolCatBytes == 0) {
673 Jmsg(jcr, M_WARNING, 0, _("Device %s not configured to autolabel Volumes.\n"),
676 /* If not removable, Volume is broken */
677 if (!dev->is_removable()) {
678 Jmsg(jcr, M_WARNING, 0, _("Volume \"%s\" not on device %s.\n"),
679 VolumeName, dev->print_name());
680 mark_volume_in_error();
688 * Mark volume in error in catalog
690 void DCR::mark_volume_in_error()
692 Jmsg(jcr, M_INFO, 0, _("Marking Volume \"%s\" in Error in Catalog.\n"),
694 dev->VolCatInfo = VolCatInfo; /* structure assignment */
695 bstrncpy(dev->VolCatInfo.VolCatStatus, "Error", sizeof(dev->VolCatInfo.VolCatStatus));
696 Dmsg0(150, "dir_update_vol_info. Set Error.\n");
697 dir_update_volume_info(this, false, false);
699 Dmsg0(50, "set_unload\n");
700 dev->set_unload(); /* must get a new volume */
704 * The Volume is not in the correct slot, so mark this
705 * Volume as not being in the Changer.
707 void DCR::mark_volume_not_inchanger()
709 Jmsg(jcr, M_ERROR, 0, _("Autochanger Volume \"%s\" not found in slot %d.\n"
710 " Setting InChanger to zero in catalog.\n"),
711 VolCatInfo.VolCatName, VolCatInfo.Slot);
712 dev->VolCatInfo = VolCatInfo; /* structure assignment */
713 VolCatInfo.InChanger = false;
714 dev->VolCatInfo.InChanger = false;
715 Dmsg0(400, "update vol info in mount\n");
716 dir_update_volume_info(this, true, false); /* set new status */
720 * Either because we are going to hang a new volume, or because
721 * of explicit user request, we release the current volume.
723 void DCR::release_volume()
725 unload_autochanger(this, -1);
728 Jmsg0(jcr, M_ERROR, 0, _("Hey!!!!! WroteVol non-zero !!!!!\n"));
729 Pmsg0(190, "Hey!!!!! WroteVol non-zero !!!!!\n");
732 * First erase all memory of the current volume
735 dev->block_num = dev->file = 0;
736 dev->EndBlock = dev->EndFile = 0;
737 memset(&dev->VolCatInfo, 0, sizeof(dev->VolCatInfo));
739 /* Force re-read of label */
740 dev->clear_labeled();
743 dev->label_type = B_BACULA_LABEL;
746 if (dev->is_open() && (!dev->is_tape() || !dev->has_cap(CAP_ALWAYSOPEN))) {
750 /* If we have not closed the device, then at least rewind the tape */
751 if (dev->is_open()) {
752 dev->offline_or_rewind();
754 // Dmsg0(50, "set_unload\n");
755 // dev->set_unload();
756 Dmsg0(190, "release_volume\n");
762 * Check to see if the tape position as defined by the OS is
763 * the same as our concept. If it is not,
764 * it means the user has probably manually rewound the tape.
765 * Note, we check only if num_writers == 0, but this code will
766 * also work fine for any number of writers. If num_writers > 0,
767 * we probably should cancel all jobs using this device, or
768 * perhaps even abort the SD, or at a minimum, mark the tape
769 * in error. Another strategy with num_writers == 0, would be
770 * to rewind the tape and do a new eod() request.
772 bool DCR::is_tape_position_ok()
774 if (dev->is_tape() && dev->num_writers == 0) {
775 int32_t file = dev->get_os_tape_file();
776 if (file >= 0 && file != (int32_t)dev->get_file()) {
777 Jmsg(jcr, M_ERROR, 0, _("Invalid tape position on volume \"%s\""
778 " on device %s. Expected %d, got %d\n"),
779 dev->VolHdr.VolumeName, dev->print_name(), dev->get_file(), file);
781 * If the current file is greater than zero, it means we probably
782 * have some bad count of EOF marks, so mark tape in error. Otherwise
783 * the operator might have moved the tape, so we just release it
787 mark_volume_in_error();
798 * If we are reading, we come here at the end of the tape
799 * and see if there are more volumes to be mounted.
801 bool mount_next_read_volume(DCR *dcr)
803 DEVICE *dev = dcr->dev;
805 Dmsg2(90, "NumReadVolumes=%d CurReadVolume=%d\n", jcr->NumReadVolumes, jcr->CurReadVolume);
807 volume_unused(dcr); /* release current volume */
809 * End Of Tape -- mount next Volume (if another specified)
811 if (jcr->NumReadVolumes > 1 && jcr->CurReadVolume < jcr->NumReadVolumes) {
813 if (!acquire_device_for_read(dcr)) {
814 Jmsg2(jcr, M_FATAL, 0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(),
818 return true; /* next volume mounted */
820 Dmsg0(90, "End of Device reached.\n");