2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-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.
29 * Drive reservation functions for Storage Daemon
33 * Split from job.c and acquire.c June 2005
42 const int dbglvl = 50;
44 static dlist *vol_list = NULL;
45 static brwlock_t reservation_lock;
46 static brwlock_t vol_list_lock;
48 /* Forward referenced functions */
49 static int can_reserve_drive(DCR *dcr, RCTX &rctx);
50 static int reserve_device(RCTX &rctx);
51 static bool reserve_device_for_read(DCR *dcr);
52 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx);
53 static bool use_storage_cmd(JCR *jcr);
54 static void queue_reserve_message(JCR *jcr);
55 static void pop_reserve_messages(JCR *jcr);
57 /* Requests from the Director daemon */
58 static char use_storage[] = "use storage=%127s media_type=%127s "
59 "pool_name=%127s pool_type=%127s append=%d copy=%d stripe=%d\n";
60 static char use_device[] = "use device=%127s\n";
62 /* Responses sent to Director daemon */
63 static char OK_device[] = "3000 OK use device device=%s\n";
64 static char NO_device[] = "3924 Device \"%s\" not in SD Device resources.\n";
65 static char BAD_use[] = "3913 Bad use command: %s\n";
67 bool use_cmd(JCR *jcr)
70 * Get the device, media, and pool information
72 if (!use_storage_cmd(jcr)) {
73 set_jcr_job_status(jcr, JS_ErrorTerminated);
74 memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
80 static int my_compare(void *item1, void *item2)
82 return strcmp(((VOLRES *)item1)->vol_name, ((VOLRES *)item2)->vol_name);
86 * This allows a given thread to recursively call lock_reservations.
87 * It must, of course, call unlock_... the same number of times.
89 void init_reservations_lock()
92 if ((errstat=rwl_init(&reservation_lock)) != 0) {
94 Emsg1(M_ABORT, 0, _("Unable to initialize reservation lock. ERR=%s\n"),
95 be.bstrerror(errstat));
98 if ((errstat=rwl_init(&vol_list_lock)) != 0) {
100 Emsg1(M_ABORT, 0, _("Unable to initialize volume list lock. ERR=%s\n"),
101 be.bstrerror(errstat));
105 void term_reservations_lock()
107 rwl_destroy(&reservation_lock);
108 rwl_destroy(&vol_list_lock);
111 int reservations_lock_count = 0;
113 /* This applies to a drive and to Volumes */
114 void _lock_reservations()
117 reservations_lock_count++;
118 if ((errstat=rwl_writelock(&reservation_lock)) != 0) {
120 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
121 errstat, be.bstrerror(errstat));
125 void _unlock_reservations()
128 reservations_lock_count--;
129 if ((errstat=rwl_writeunlock(&reservation_lock)) != 0) {
131 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
132 errstat, be.bstrerror(errstat));
136 int vol_list_lock_count = 0;
139 * This allows a given thread to recursively call to lock_volumes()
144 vol_list_lock_count++;
145 if ((errstat=rwl_writelock(&vol_list_lock)) != 0) {
147 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
148 errstat, be.bstrerror(errstat));
152 void _unlock_volumes()
155 vol_list_lock_count--;
156 if ((errstat=rwl_writeunlock(&vol_list_lock)) != 0) {
158 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
159 errstat, be.bstrerror(errstat));
165 * List Volumes -- this should be moved to status.c
172 static void debug_list_volumes(const char *imsg)
175 POOL_MEM msg(PM_MESSAGE);
178 foreach_dlist(vol, vol_list) {
180 Mmsg(msg, "List %s: %s rel=%d on device %s\n", imsg,
181 vol->vol_name, vol->released, vol->dev->print_name());
183 Mmsg(msg, "List %s: %s rel=%d no dev\n", imsg, vol->vol_name, vol->released);
185 Dmsg1(dbglvl, "%s", msg.c_str());
190 foreach_dlist(vol, vol_list) {
191 if (vol->dev == dev) {
192 Dmsg0(dbglvl, "Two Volumes on same device.\n");
199 // Dmsg2(dbglvl, "List from %s: %d volumes\n", imsg, count);
205 * List Volumes -- this should be moved to status.c
207 void list_volumes(void sendit(const char *msg, int len, void *sarg), void *arg)
210 POOL_MEM msg(PM_MESSAGE);
214 foreach_dlist(vol, vol_list) {
215 DEVICE *dev = vol->dev;
217 len = Mmsg(msg, "%s on device %s\n", vol->vol_name, dev->print_name());
218 sendit(msg.c_str(), len, arg);
219 len = Mmsg(msg, " Reader=%d writers=%d reserved=%d released=%d\n",
220 dev->can_read()?1:0, dev->num_writers, dev->reserved_device, vol->released);
221 sendit(msg.c_str(), len, arg);
223 len = Mmsg(msg, "%s no device. released=%d\n", vol->vol_name, vol->released);
224 sendit(msg.c_str(), len, arg);
231 * Create a Volume item to put in the Volume list
232 * Ensure that the device points to it.
234 static VOLRES *new_vol_item(DCR *dcr, const char *VolumeName)
237 vol = (VOLRES *)malloc(sizeof(VOLRES));
238 memset(vol, 0, sizeof(VOLRES));
239 vol->vol_name = bstrdup(VolumeName);
241 Dmsg3(dbglvl, "new Vol=%s at %p dev=%s\n",
242 VolumeName, vol->vol_name, vol->dev->print_name());
246 static void free_vol_item(VOLRES *vol)
250 vol->dev->vol = NULL;
257 * Put a new Volume entry in the Volume list. This
258 * effectively reserves the volume so that it will
259 * not be mounted again.
261 * If the device has any current volume associated with it,
262 * and it is a different Volume, and the device is not busy,
263 * we release the old Volume item and insert the new one.
265 * It is assumed that the device is free and locked so that
266 * we can change the device structure.
268 * Some details of the Volume list handling:
270 * 1. The Volume list entry must be attached to the drive (rather than
271 * attached to a job as it currently is. I.e. the drive that "owns"
272 * the volume (reserved, in use, mounted)
273 * must point to the volume (still to be maintained in a list).
275 * 2. The Volume is entered in the list when a drive is reserved.
277 * 3. When a drive is in use, the device code must appropriately update the
278 * volume name as it changes (currently the list is static -- an entry is
279 * removed when the Volume is no longer reserved, in use or mounted).
280 * The new code must keep the same list entry as long as the drive
281 * has any volume associated with it but the volume name in the list
282 * must be updated when the drive has a different volume mounted.
284 * 4. A job that has reserved a volume, can un-reserve the volume, and if the
285 * volume is not mounted, and not reserved, and not in use, it will be
286 * removed from the list.
288 * 5. If a job wants to reserve a drive with a different Volume from the one on
289 * the drive, it can re-use the drive for the new Volume.
291 * 6. If a job wants a Volume that is in a different drive, it can either use the
292 * other drive or take the volume, only if the other drive is not in use or
295 * One nice aspect of this is that the reserve use count and the writer use count
296 * already exist and are correctly programmed and will need no changes -- use
297 * counts are always very tricky.
299 * The old code had a concept of "reserving" a Volume, but was changed
300 * to reserving and using a drive. A volume is must be attached to (owned by) a
301 * drive and can move from drive to drive or be unused given certain specific
302 * conditions of the drive. The key is that the drive must "own" the Volume.
303 * The old code had the job (dcr) owning the volume (more or less). The job was
304 * to change the insertion and removal of the volumes from the list to be based
305 * on the drive rather than the job.
307 * Return: VOLRES entry on success
308 * NULL volume busy on another drive
310 VOLRES *reserve_volume(DCR *dcr, const char *VolumeName)
313 DEVICE *dev = dcr->dev;
317 Dmsg1(dbglvl, "enter reserve_volume %s\n", VolumeName);
319 * We lock the reservations system here to ensure
320 * when adding a new volume that no newly scheduled
321 * job can reserve it.
324 debug_list_volumes("begin reserve_volume");
326 * First, remove any old volume attached to this device as it
331 Dmsg4(dbglvl, "Vol attached=%s, newvol=%s release=%d on %s\n",
332 vol->vol_name, VolumeName, vol->released, dev->print_name());
334 * Make sure we don't remove the current volume we are inserting
335 * because it was probably inserted by another job, or it
336 * is not being used and is marked as released.
338 if (strcmp(vol->vol_name, VolumeName) == 0) {
339 Dmsg1(dbglvl, "=== OK, vol=%s on device. set not released.\n", VolumeName);
340 goto get_out; /* Volume already on this device */
342 Dmsg2(dbglvl, "reserve_vol free vol=%s at %p\n", vol->vol_name, vol->vol_name);
343 unload_autochanger(dcr, -1); /* unload the volume */
345 debug_list_volumes("reserve_vol free");
349 /* Create a new Volume entry */
350 nvol = new_vol_item(dcr, VolumeName);
353 * Now try to insert the new Volume
355 vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
357 Dmsg2(dbglvl, "Found vol=%s dev-same=%d\n", vol->vol_name, dev==vol->dev);
359 * At this point, a Volume with this name already is in the list,
360 * so we simply release our new Volume entry. Note, this should
361 * only happen if we are moving the volume from one drive to another.
363 Dmsg2(dbglvl, "reserve_vol free-tmp vol=%s at %p\n",
364 vol->vol_name, vol->vol_name);
366 * Clear dev pointer so that free_vol_item() doesn't
367 * take away our volume.
369 nvol->dev = NULL; /* don't zap dev entry */
372 /* Check if we are trying to use the Volume on a different drive */
373 if (dev != vol->dev) {
374 /* Caller wants to switch Volume to another device */
375 if (!vol->dev->is_busy()) {
376 /* OK to move it -- I'm not sure this will work */
377 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n", VolumeName,
378 vol->dev->print_name(), dev->print_name());
379 vol->dev->vol = NULL; /* take vol from old drive */
380 vol->dev->VolHdr.VolumeName[0] = 0;
381 vol->dev = dev; /* point vol at new drive */
382 dev->vol = vol; /* point dev at vol */
383 dev->VolHdr.VolumeName[0] = 0;
385 Dmsg3(dbglvl, "Volume busy could not swap vol=%s from dev=%s to %s\n",
386 VolumeName, vol->dev->print_name(), dev->print_name());
387 vol = NULL; /* device busy */
396 Dmsg1(dbglvl, "=== set not released. vol=%s\n", vol->vol_name);
397 vol->released = false;
399 debug_list_volumes("end new volume");
405 * Switch from current device to given device
408 void switch_device(DCR *dcr, DEVICE *dev)
410 // lock_reservations();
414 memcpy(&save_dcr, dcr, sizeof(save_dcr));
415 clean_device(dcr); /* clean up the dcr */
417 dcr->dev = dev; /* get new device pointer */
418 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
419 dcr->dev->print_name());
421 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
422 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
423 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
424 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
425 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
426 bstrncpy(dcr->dev_name, save_dcr.dev_name, sizeof(dcr->dev_name));
428 dev->reserved_device++;
429 dcr->reserved_device = true;
435 * Search for a Volume name in the Volume list.
437 * Returns: VOLRES entry on success
438 * NULL if the Volume is not in the list
440 VOLRES *find_volume(DCR *dcr)
443 /* Do not lock reservations here */
445 vol.vol_name = bstrdup(dcr->VolumeName);
446 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
448 Dmsg2(dbglvl, "find_vol=%s found=%d\n", dcr->VolumeName, fvol!=NULL);
449 debug_list_volumes("find_volume");
455 * Remove any reservation from a drive and tell the system
456 * that the volume is unused at least by us.
458 void unreserve_device(DCR *dcr)
460 DEVICE *dev = dcr->dev;
461 if (dcr->reserved_device) {
462 dcr->reserved_device = false;
463 dev->reserved_device--;
464 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name());
465 dcr->reserved_device = false;
466 /* If we set read mode in reserving, remove it */
467 if (dev->can_read()) {
470 if (dev->num_writers < 0) {
471 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
472 dev->num_writers = 0;
480 * Free a Volume from the Volume list if it is no longer used
481 * Note, for tape drives we want to remember where the Volume
482 * was when last used, so rather than free the volume entry,
483 * we simply mark it "released" so when the drive is really
484 * needed for another volume, we can reuse it.
486 * Returns: true if the Volume found and "removed" from the list
487 * false if the Volume is not in the list or is in use
489 bool volume_unused(DCR *dcr)
491 DEVICE *dev = dcr->dev;
493 if (dev->vol == NULL) {
494 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
495 debug_list_volumes("null vol cannot unreserve_volume");
499 if (dev->is_busy()) {
500 Dmsg1(dbglvl, "vol_unused: busy on %s\n", dev->print_name());
501 debug_list_volumes("dev busy cannot unreserve_volume");
505 if (dev->num_writers > 0 || dev->reserved_device > 0) {
511 * If this is a tape, we do not free the volume, rather we wait
512 * until the autoloader unloads it, or until another tape is
513 * explicitly read in this drive. This allows the SD to remember
514 * where the tapes are or last were.
516 Dmsg3(dbglvl, "=== mark released vol=%s num_writers=%d reserved=%d\n",
517 dev->vol->vol_name, dev->num_writers, dev->reserved_device);
518 dev->vol->released = true;
519 if (dev->is_tape() || dev->is_autochanger()) {
523 * Note, this frees the volume reservation entry, but the
524 * file descriptor remains open with the OS.
526 return free_volume(dev);
531 * Unconditionally release the volume entry
533 bool free_volume(DEVICE *dev)
537 if (dev->vol == NULL) {
538 Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name());
544 vol_list->remove(vol);
545 Dmsg2(dbglvl, "=== free_volume %s dev=%s\n", vol->vol_name, dev->print_name());
547 debug_list_volumes("free_volume");
553 /* Create the Volume list */
554 void create_volume_list()
557 if (vol_list == NULL) {
558 vol_list = New(dlist(vol, &vol->link));
562 /* Release all Volumes from the list */
563 void free_volume_list()
570 foreach_dlist(vol, vol_list) {
572 Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name());
574 Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name);
577 vol->vol_name = NULL;
584 bool is_volume_in_use(DCR *dcr)
586 VOLRES *vol = find_volume(dcr);
588 Dmsg1(dbglvl, "Vol=%s not in use.\n", dcr->VolumeName);
589 return false; /* vol not in list */
591 ASSERT(vol->dev != NULL);
593 if (dcr->dev == vol->dev) { /* same device OK */
594 Dmsg1(dbglvl, "Vol=%s on same dev.\n", dcr->VolumeName);
597 Dmsg3(dbglvl, "Vol=%s on %s we have %s\n", dcr->VolumeName,
598 vol->dev->print_name(), dcr->dev->print_name());
600 if (!vol->dev->is_busy()) {
601 Dmsg2(dbglvl, "Vol=%s dev=%s not busy.\n", dcr->VolumeName, vol->dev->print_name());
604 Dmsg2(dbglvl, "Vol=%s dev=%s busy.\n", dcr->VolumeName, vol->dev->print_name());
606 Dmsg2(dbglvl, "Vol=%s in use by %s.\n", dcr->VolumeName, vol->dev->print_name());
612 * We get the following type of information:
614 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
618 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
622 static bool use_storage_cmd(JCR *jcr)
624 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
625 BSOCK *dir = jcr->dir_bsock;
633 memset(&rctx, 0, sizeof(RCTX));
636 * If there are multiple devices, the director sends us
637 * use_device for each device that it wants to use.
639 dirstore = New(alist(10, not_owned_by_alist));
640 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
642 Dmsg1(dbglvl, "<dird: %s", dir->msg);
643 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
644 media_type.c_str(), pool_name.c_str(),
645 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
650 jcr->write_store = dirstore;
652 jcr->read_store = dirstore;
654 rctx.append = append;
655 unbash_spaces(store_name);
656 unbash_spaces(media_type);
657 unbash_spaces(pool_name);
658 unbash_spaces(pool_type);
659 store = new DIRSTORE;
660 dirstore->append(store);
661 memset(store, 0, sizeof(DIRSTORE));
662 store->device = New(alist(10));
663 bstrncpy(store->name, store_name, sizeof(store->name));
664 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
665 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
666 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
667 store->append = append;
669 /* Now get all devices */
670 while (dir->recv() >= 0) {
671 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
672 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
676 unbash_spaces(dev_name);
677 store->device->append(bstrdup(dev_name.c_str()));
679 } while (ok && dir->recv() >= 0);
681 /* Developer debug code */
683 if (debug_level >= dbglvl) {
684 foreach_alist(store, dirstore) {
685 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
686 store->name, store->media_type, store->pool_name,
687 store->pool_type, store->append);
688 foreach_alist(device_name, store->device) {
689 Dmsg1(dbglvl, " Device=%s\n", device_name);
694 init_jcr_device_wait_timers(jcr);
695 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
697 BSOCK *dir = jcr->dir_bsock;
698 dir->fsend(_("3939 Could not get dcr\n"));
699 Dmsg1(dbglvl, ">dird: %s", dir->msg);
703 * At this point, we have a list of all the Director's Storage
704 * resources indicated for this Job, which include Pool, PoolType,
705 * storage name, and Media type.
706 * Then for each of the Storage resources, we have a list of
707 * device names that were given.
709 * Wiffle through them and find one that can do the backup.
712 int wait_for_device_retries = 0;
715 rctx.notify_dir = true;
718 for ( ; !fail && !job_canceled(jcr); ) {
719 pop_reserve_messages(jcr);
720 rctx.suitable_device = false;
721 rctx.have_volume = false;
722 rctx.VolumeName[0] = 0;
723 rctx.any_drive = false;
724 if (!jcr->PreferMountedVols) {
726 * Here we try to find a drive that is not used.
727 * This will maximize the use of available drives.
730 rctx.num_writers = 20000000; /* start with impossible number */
731 rctx.low_use_drive = NULL;
732 rctx.PreferMountedVols = false;
733 rctx.exact_match = false;
734 rctx.autochanger_only = true;
735 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
736 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
737 rctx.autochanger_only, rctx.any_drive);
738 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
741 /* Look through all drives possibly for low_use drive */
742 if (rctx.low_use_drive) {
743 rctx.try_low_use_drive = true;
744 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
747 rctx.try_low_use_drive = false;
749 rctx.autochanger_only = false;
750 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
751 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
752 rctx.autochanger_only, rctx.any_drive);
753 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
758 * Now we look for a drive that may or may not be in
761 /* Look for an exact Volume match all drives */
762 rctx.PreferMountedVols = true;
763 rctx.exact_match = true;
764 rctx.autochanger_only = false;
765 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
766 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
767 rctx.autochanger_only, rctx.any_drive);
768 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
771 /* Look for any mounted drive */
772 rctx.exact_match = false;
773 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
774 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
775 rctx.autochanger_only, rctx.any_drive);
776 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
780 rctx.any_drive = true;
781 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
782 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
783 rctx.autochanger_only, rctx.any_drive);
784 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
787 /* Keep reservations locked *except* during wait_for_device() */
788 unlock_reservations();
790 * The idea of looping on repeat a few times it to ensure
791 * that if there is some subtle timing problem between two
792 * jobs, we will simply try again, and most likely succeed.
793 * This can happen if one job reserves a drive or finishes using
794 * a drive at the same time a second job wants it.
796 if (repeat++ > 1) { /* try algorithm 3 times */
797 bmicrosleep(30, 0); /* wait a bit */
798 Dmsg0(dbglvl, "repeat reserve algorithm\n");
799 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
800 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
804 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
806 unlock_reservations();
809 * If we get here, there are no suitable devices available, which
810 * means nothing configured. If a device is suitable but busy
811 * with another Volume, we will not come here.
813 unbash_spaces(dir->msg);
814 pm_strcpy(jcr->errmsg, dir->msg);
815 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
816 Jmsg(jcr, M_FATAL, 0, _("\n"
817 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
818 dev_name.c_str(), media_type.c_str());
819 dir->fsend(NO_device, dev_name.c_str());
821 Dmsg1(dbglvl, ">dird: %s", dir->msg);
824 unbash_spaces(dir->msg);
825 pm_strcpy(jcr->errmsg, dir->msg);
826 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
827 dir->fsend(BAD_use, jcr->errmsg);
828 Dmsg1(dbglvl, ">dird: %s", dir->msg);
831 release_reserve_messages(jcr);
837 * Walk through the autochanger resources and check if
838 * the volume is in one of them.
840 * Returns: true if volume is in device
843 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
845 AUTOCHANGER *changer = vol->dev->device->changer_res;
847 /* Find resource, and make sure we were able to open it */
848 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
849 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
852 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
857 * Search for a device suitable for this job.
859 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
868 dirstore = jcr->write_store;
870 dirstore = jcr->read_store;
872 Dmsg4(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
873 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
874 rctx.autochanger_only);
877 * If the appropriate conditions of this if are met, namely that
878 * we are appending and the user wants mounted drive (or we
879 * force try a mounted drive because they are all busy), we
880 * start by looking at all the Volumes in the volume list.
882 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
883 dlist *temp_vol_list, *save_vol_list;
886 Dmsg0(dbglvl, "lock volumes\n");
889 * Create a temporary copy of the volume list. We do this,
890 * to avoid having the volume list locked during the
891 * call to reserve_device(), which would cause a deadlock.
892 * Note, we may want to add an update counter on the vol_list
893 * so that if it is modified while we are traversing the copy
894 * we can take note and act accordingly (probably redo the
895 * search at least a few times).
897 Dmsg0(dbglvl, "duplicate vol list\n");
898 temp_vol_list = New(dlist(vol, &vol->link));
899 foreach_dlist(vol, vol_list) {
901 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
902 memset(tvol, 0, sizeof(VOLRES));
903 tvol->vol_name = bstrdup(vol->vol_name);
904 tvol->dev = vol->dev;
905 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
907 tvol->dev = NULL; /* don't zap dev entry */
909 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
910 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
913 Dmsg0(dbglvl, "unlock volumes\n");
916 /* Look through reserved volumes for one we can use */
917 Dmsg0(dbglvl, "look for vol in vol list\n");
918 foreach_dlist(vol, temp_vol_list) {
920 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
923 /* Check with Director if this Volume is OK */
924 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
925 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
929 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
930 foreach_alist(store, dirstore) {
933 foreach_alist(device_name, store->device) {
934 /* Found a device, try to use it */
935 rctx.device_name = device_name;
936 rctx.device = vol->dev->device;
938 if (vol->dev->is_autochanger()) {
939 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
940 if (!is_vol_in_autochanger(rctx, vol)) {
943 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
944 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
945 vol->dev->device->hdr.name, device_name);
949 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
950 rctx.have_volume = true;
951 /* Try reserving this device and volume */
952 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
953 stat = reserve_device(rctx);
954 if (stat == 1) { /* found available device */
955 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
958 } else if (stat == 0) { /* device busy */
959 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
961 /* otherwise error */
962 Dmsg0(dbglvl, "No suitable device found.\n");
964 rctx.have_volume = false;
965 rctx.VolumeName[0] = 0;
974 } /* end for loop over reserved volumes */
976 Dmsg0(dbglvl, "lock volumes\n");
978 save_vol_list = vol_list;
979 vol_list = temp_vol_list;
980 free_volume_list(); /* release temp_vol_list */
981 vol_list = save_vol_list;
982 Dmsg0(dbglvl, "deleted temp vol list\n");
983 Dmsg0(dbglvl, "unlock volumes\n");
985 debug_list_volumes("=== After free temp table\n");
988 Dmsg1(dbglvl, "got vol %s from in-use vols list\n", rctx.VolumeName);
993 * No reserved volume we can use, so now search for an available device.
995 * For each storage device that the user specified, we
996 * search and see if there is a resource for that device.
998 foreach_alist(store, dirstore) {
1000 foreach_alist(device_name, store->device) {
1002 rctx.device_name = device_name;
1003 stat = search_res_for_device(rctx);
1004 if (stat == 1) { /* found available device */
1005 Dmsg1(dbglvl, "available device found=%s\n", device_name);
1008 } else if (stat == 0) { /* device busy */
1009 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
1011 /* otherwise error */
1012 Dmsg0(dbglvl, "No suitable device found.\n");
1023 * Search for a particular storage device with particular storage
1024 * characteristics (MediaType).
1026 int search_res_for_device(RCTX &rctx)
1028 AUTOCHANGER *changer;
1031 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
1032 /* Look through Autochangers first */
1033 foreach_res(changer, R_AUTOCHANGER) {
1034 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
1035 /* Find resource, and make sure we were able to open it */
1036 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1037 /* Try each device in this AutoChanger */
1038 foreach_alist(rctx.device, changer->device) {
1039 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
1040 stat = reserve_device(rctx);
1041 if (stat != 1) { /* try another device */
1045 if (rctx.store->append == SD_APPEND) {
1046 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1047 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1049 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1050 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1057 /* Now if requested look through regular devices */
1058 if (!rctx.autochanger_only) {
1059 foreach_res(rctx.device, R_DEVICE) {
1060 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
1061 /* Find resource, and make sure we were able to open it */
1062 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1063 stat = reserve_device(rctx);
1064 if (stat != 1) { /* try another device */
1068 if (rctx.store->append == SD_APPEND) {
1069 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1070 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1072 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1073 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1079 return -1; /* nothing found */
1083 * Try to reserve a specific device.
1085 * Returns: 1 -- OK, have DCR
1089 static int reserve_device(RCTX &rctx)
1093 const int name_len = MAX_NAME_LENGTH;
1095 /* Make sure MediaType is OK */
1096 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
1097 rctx.device->media_type, rctx.store->media_type);
1098 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1102 /* Make sure device exists -- i.e. we can stat() it */
1103 if (!rctx.device->dev) {
1104 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1106 if (!rctx.device->dev) {
1107 if (rctx.device->changer_res) {
1108 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1109 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1110 rctx.device->hdr.name, rctx.device_name);
1112 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1113 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1116 return -1; /* no use waiting */
1119 rctx.suitable_device = true;
1120 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1121 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1123 BSOCK *dir = rctx.jcr->dir_bsock;
1124 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1125 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1128 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1129 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1130 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1131 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1132 if (rctx.store->append == SD_APPEND) {
1133 Dmsg2(dbglvl, "call reserve for append: have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
1134 ok = reserve_device_for_append(dcr, rctx);
1139 rctx.jcr->dcr = dcr;
1140 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1141 dcr->dev->reserved_device,
1142 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1143 Dmsg3(dbglvl, "Vol=%s num_writers=%d, have_vol=%d\n",
1144 rctx.VolumeName, dcr->dev->num_writers, rctx.have_volume);
1145 if (!rctx.have_volume) {
1146 dcr->any_volume = true;
1147 Dmsg0(dbglvl, "no vol, call find_next_appendable_vol.\n");
1148 if (dir_find_next_appendable_volume(dcr)) {
1149 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1150 rctx.have_volume = true;
1151 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
1153 Dmsg0(dbglvl, "No next volume found\n");
1155 * If there is at least one volume that is valid and in use,
1156 * but we get here, check if we are running with prefers
1157 * non-mounted drives. In that case, we have selected a
1158 * non-used drive and our one and only volume is mounted
1159 * elsewhere, so we bail out and retry using that drive.
1161 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1162 rctx.PreferMountedVols = true;
1163 if (dcr->VolumeName[0]) {
1169 * Note. Under some circumstances, the Director can hand us
1170 * a Volume name that is no the same as the one on the current
1171 * drive, and in that case, the call above to find the next
1172 * volume will fail because in attempting to reserve the Volume
1173 * the code will realize that we already have a tape mounted,
1174 * and it will fail. This *should* only happen if there are
1175 * writers, thus the following test. In that case, we simply
1176 * bail out, and continue waiting, rather than plunging on
1177 * and hoping that the operator can resolve the problem.
1179 if (dcr->dev->num_writers != 0) {
1180 if (dcr->VolumeName[0]) {
1185 rctx.have_volume = false;
1186 rctx.VolumeName[0] = 0;
1190 ok = reserve_device_for_read(dcr);
1192 rctx.jcr->read_dcr = dcr;
1193 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1194 dcr->dev->reserved_device,
1195 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1202 if (rctx.notify_dir) {
1204 BSOCK *dir = rctx.jcr->dir_bsock;
1205 pm_strcpy(dev_name, rctx.device->hdr.name);
1206 bash_spaces(dev_name);
1207 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1208 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1215 rctx.have_volume = false;
1216 rctx.VolumeName[0] = 0;
1218 Dmsg0(dbglvl, "Not OK.\n");
1223 * We "reserve" the drive by setting the ST_READ bit. No one else
1224 * should touch the drive until that is cleared.
1225 * This allows the DIR to "reserve" the device before actually
1228 static bool reserve_device_for_read(DCR *dcr)
1230 DEVICE *dev = dcr->dev;
1231 JCR *jcr = dcr->jcr;
1238 if (is_device_unmounted(dev)) {
1239 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
1240 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1241 jcr->JobId, dev->print_name());
1242 queue_reserve_message(jcr);
1246 if (dev->is_busy()) {
1247 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1249 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1250 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1251 jcr->JobId, dev->print_name());
1252 queue_reserve_message(jcr);
1256 dev->clear_append();
1259 dev->reserved_device++;
1260 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev);
1261 dcr->reserved_device = true;
1270 * We reserve the device for appending by incrementing the
1271 * reserved_device. We do virtually all the same work that
1272 * is done in acquire_device_for_append(), but we do
1273 * not attempt to mount the device. This routine allows
1274 * the DIR to reserve multiple devices before *really*
1275 * starting the job. It also permits the SD to refuse
1276 * certain devices (not up, ...).
1278 * Note, in reserving a device, if the device is for the
1279 * same pool and the same pool type, then it is acceptable.
1280 * The Media Type has already been checked. If we are
1281 * the first tor reserve the device, we put the pool
1282 * name and pool type in the device record.
1284 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1286 JCR *jcr = dcr->jcr;
1287 DEVICE *dev = dcr->dev;
1294 /* If device is being read, we cannot write it */
1295 if (dev->can_read()) {
1296 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1297 jcr->JobId, dev->print_name());
1298 Dmsg1(dbglvl, "%s", jcr->errmsg);
1299 queue_reserve_message(jcr);
1303 /* If device is unmounted, we are out of luck */
1304 if (is_device_unmounted(dev)) {
1305 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1306 jcr->JobId, dev->print_name());
1307 Dmsg1(dbglvl, "%s", jcr->errmsg);
1308 queue_reserve_message(jcr);
1312 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
1314 /* Now do detailed tests ... */
1315 if (can_reserve_drive(dcr, rctx) != 1) {
1316 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
1320 dev->reserved_device++;
1321 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device,
1322 dev->print_name(), dev);
1323 dcr->reserved_device = true;
1331 static int is_pool_ok(DCR *dcr)
1333 DEVICE *dev = dcr->dev;
1334 JCR *jcr = dcr->jcr;
1336 /* Now check if we want the same Pool and pool type */
1337 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1338 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1339 /* OK, compatible device */
1340 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1343 /* Drive Pool not suitable for us */
1344 Mmsg(jcr->errmsg, _(
1345 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1346 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1347 dev->reserved_device, dev->print_name());
1348 queue_reserve_message(jcr);
1349 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1350 dev->pool_name, dcr->pool_name);
1355 static bool is_max_jobs_ok(DCR *dcr)
1357 DEVICE *dev = dcr->dev;
1358 JCR *jcr = dcr->jcr;
1360 Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n",
1361 dcr->VolCatInfo.VolCatMaxJobs,
1362 dcr->VolCatInfo.VolCatJobs, dev->reserved_device,
1364 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1365 (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) {
1366 /* Max Job Vols depassed or already reserved */
1367 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1368 (uint32_t)jcr->JobId, dev->print_name());
1369 queue_reserve_message(jcr);
1370 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1371 return false; /* wait */
1377 * Returns: 1 if drive can be reserved
1378 * 0 if we should wait
1379 * -1 on error or impossibility
1381 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1383 DEVICE *dev = dcr->dev;
1384 JCR *jcr = dcr->jcr;
1386 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1387 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1388 rctx.autochanger_only, rctx.any_drive);
1390 /* Check for max jobs on this Volume */
1391 if (!is_max_jobs_ok(dcr)) {
1395 /* setting any_drive overrides PreferMountedVols flag */
1396 if (!rctx.any_drive) {
1398 * When PreferMountedVols is set, we keep track of the
1399 * drive in use that has the least number of writers, then if
1400 * no unmounted drive is found, we try that drive. This
1401 * helps spread the load to the least used drives.
1403 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1404 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
1405 dev->print_name(), rctx.low_use_drive->print_name());
1408 /* If he wants a free drive, but this one is busy, no go */
1409 if (!rctx.PreferMountedVols && dev->is_busy()) {
1410 /* Save least used drive */
1411 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1412 rctx.num_writers = dev->num_writers + dev->reserved_device;
1413 rctx.low_use_drive = dev;
1414 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
1415 dev->print_name(), rctx.num_writers);
1417 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->reserved_device);
1419 Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
1420 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1421 jcr->JobId, dev->print_name());
1422 queue_reserve_message(jcr);
1426 /* Check for prefer mounted volumes */
1427 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1428 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1429 jcr->JobId, dev->print_name());
1430 queue_reserve_message(jcr);
1431 Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
1432 return 0; /* No volume mounted */
1435 /* Check for exact Volume name match */
1436 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1439 if (rctx.exact_match && rctx.have_volume) {
1441 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1442 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1443 rctx.autochanger_only, rctx.any_drive);
1444 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1445 rctx.have_volume, dev->VolHdr.VolumeName,
1446 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1447 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1448 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1450 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1451 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1453 queue_reserve_message(jcr);
1454 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1455 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1458 if (is_volume_in_use(dcr)) {
1459 return 0; /* fail if volume on another drive */
1464 /* Check for unused autochanger drive */
1465 if (rctx.autochanger_only && !dev->is_busy() &&
1466 dev->VolHdr.VolumeName[0] == 0) {
1467 /* Device is available but not yet reserved, reserve it for us */
1468 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1469 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1470 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1471 return 1; /* reserve drive */
1475 * Handle the case that there are no writers
1477 if (dev->num_writers == 0) {
1478 /* Now check if there are any reservations on the drive */
1479 if (dev->reserved_device) {
1480 return is_pool_ok(dcr);
1481 } else if (dev->can_append()) {
1482 if (is_pool_ok(dcr)) {
1485 /* Changing pool, unload old tape if any in drive */
1486 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1487 unload_autochanger(dcr, 0);
1490 /* Device is available but not yet reserved, reserve it for us */
1491 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1492 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1493 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1494 return 1; /* reserve drive */
1498 * Check if the device is in append mode with writers (i.e.
1499 * available if pool is the same).
1501 if (dev->can_append() || dev->num_writers > 0) {
1502 return is_pool_ok(dcr);
1504 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1505 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1506 jcr->JobId, dev->print_name());
1507 queue_reserve_message(jcr);
1508 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1509 return -1; /* error, should not get here */
1511 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1512 jcr->JobId, dev->print_name());
1513 queue_reserve_message(jcr);
1514 Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1522 * Queue a reservation error or failure message for this jcr
1524 static void queue_reserve_message(JCR *jcr)
1532 msgs = jcr->reserve_msgs;
1537 * Look for duplicate message. If found, do
1540 for (i=msgs->size()-1; i >= 0; i--) {
1541 msg = (char *)msgs->get(i);
1545 /* Comparison based on 4 digit message number */
1546 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1550 /* Message unique, so insert it */
1551 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1558 * Send any reservation messages queued for this jcr
1560 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1567 msgs = jcr->reserve_msgs;
1568 if (!msgs || msgs->size() == 0) {
1571 for (i=msgs->size()-1; i >= 0; i--) {
1572 msg = (char *)msgs->get(i);
1574 sendit(" ", 3, arg);
1575 sendit(msg, strlen(msg), arg);
1586 * Pop and release any reservations messages
1588 static void pop_reserve_messages(JCR *jcr)
1594 msgs = jcr->reserve_msgs;
1598 while ((msg = (char *)msgs->pop())) {
1606 * Also called from acquire.c
1608 void release_reserve_messages(JCR *jcr)
1610 pop_reserve_messages(jcr);
1612 if (!jcr->reserve_msgs) {
1615 delete jcr->reserve_msgs;
1616 jcr->reserve_msgs = NULL;