2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2007 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 #define jid() ((int)get_jobid_from_tid())
44 const int dbglvl = 50;
46 static dlist *vol_list = NULL;
47 static brwlock_t reservation_lock;
48 static brwlock_t vol_list_lock;
50 /* Forward referenced functions */
51 static int can_reserve_drive(DCR *dcr, RCTX &rctx);
52 static int reserve_device(RCTX &rctx);
53 static bool reserve_device_for_read(DCR *dcr);
54 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx);
55 static bool use_storage_cmd(JCR *jcr);
56 static void queue_reserve_message(JCR *jcr);
58 /* Requests from the Director daemon */
59 static char use_storage[] = "use storage=%127s media_type=%127s "
60 "pool_name=%127s pool_type=%127s append=%d copy=%d stripe=%d\n";
61 static char use_device[] = "use device=%127s\n";
63 /* Responses sent to Director daemon */
64 static char OK_device[] = "3000 OK use device device=%s\n";
65 static char NO_device[] = "3924 Device \"%s\" not in SD Device resources.\n";
66 static char BAD_use[] = "3913 Bad use command: %s\n";
68 bool use_cmd(JCR *jcr)
71 * Get the device, media, and pool information
73 if (!use_storage_cmd(jcr)) {
74 set_jcr_job_status(jcr, JS_ErrorTerminated);
75 memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
81 static int my_compare(void *item1, void *item2)
83 return strcmp(((VOLRES *)item1)->vol_name, ((VOLRES *)item2)->vol_name);
87 void init_reservations_lock()
90 if ((errstat=rwl_init(&reservation_lock)) != 0) {
92 Emsg1(M_ABORT, 0, _("Unable to initialize reservation lock. ERR=%s\n"),
93 be.bstrerror(errstat));
96 if ((errstat=rwl_init(&vol_list_lock)) != 0) {
98 Emsg1(M_ABORT, 0, _("Unable to initialize volume list lock. ERR=%s\n"),
99 be.bstrerror(errstat));
103 void term_reservations_lock()
105 rwl_destroy(&reservation_lock);
106 rwl_destroy(&vol_list_lock);
109 int reservations_lock_count = 0;
111 /* This applies to a drive and to Volumes */
112 void _lock_reservations()
115 reservations_lock_count++;
116 if ((errstat=rwl_writelock(&reservation_lock)) != 0) {
118 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
119 errstat, be.bstrerror(errstat));
123 void _unlock_reservations()
126 reservations_lock_count--;
127 if ((errstat=rwl_writeunlock(&reservation_lock)) != 0) {
129 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
130 errstat, be.bstrerror(errstat));
134 int vol_list_lock_count = 0;
139 vol_list_lock_count++;
140 if ((errstat=rwl_writelock(&vol_list_lock)) != 0) {
142 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
143 errstat, be.bstrerror(errstat));
147 void _unlock_volumes()
150 vol_list_lock_count--;
151 if ((errstat=rwl_writeunlock(&vol_list_lock)) != 0) {
153 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
154 errstat, be.bstrerror(errstat));
160 * List Volumes -- this should be moved to status.c
167 static void debug_list_volumes(const char *imsg)
170 POOL_MEM msg(PM_MESSAGE);
173 foreach_dlist(vol, vol_list) {
175 Mmsg(msg, "List from %s: %s at %p on device %s\n", imsg,
176 vol->vol_name, vol->vol_name, vol->dev->print_name());
178 Mmsg(msg, "List from %s: %s at %p no dev\n", imsg, vol->vol_name, vol->vol_name);
180 Dmsg2(dbglvl, "jid=%u %s", jid(), msg.c_str());
185 foreach_dlist(vol, vol_list) {
186 if (vol->dev == dev) {
187 Dmsg0(000, "Two Volumes on same device.\n");
194 // Dmsg2(dbglvl, "List from %s: %d volumes\n", imsg, count);
200 * List Volumes -- this should be moved to status.c
202 void list_volumes(void sendit(const char *msg, int len, void *sarg), void *arg)
205 POOL_MEM msg(PM_MESSAGE);
209 foreach_dlist(vol, vol_list) {
210 DEVICE *dev = vol->dev;
212 len = Mmsg(msg, "%s on device %s\n", vol->vol_name, dev->print_name());
213 sendit(msg.c_str(), len, arg);
214 len = Mmsg(msg, " Reader=%d writers=%d reserved=%d\n", dev->can_read()?1:0,
215 dev->num_writers, dev->reserved_device);
216 sendit(msg.c_str(), len, arg);
218 len = Mmsg(msg, "%s no dev\n", vol->vol_name);
219 sendit(msg.c_str(), len, arg);
226 * Create a Volume item to put in the Volume list
227 * Ensure that the device points to it.
229 static VOLRES *new_vol_item(DCR *dcr, const char *VolumeName)
232 vol = (VOLRES *)malloc(sizeof(VOLRES));
233 memset(vol, 0, sizeof(VOLRES));
234 vol->vol_name = bstrdup(VolumeName);
236 Dmsg4(dbglvl, "jid=%u new Vol=%s at %p dev=%s\n", (int)dcr->jcr->JobId,
237 VolumeName, vol->vol_name, vol->dev->print_name());
241 static void free_vol_item(VOLRES *vol)
245 vol->dev->vol = NULL;
252 * Put a new Volume entry in the Volume list. This
253 * effectively reserves the volume so that it will
254 * not be mounted again.
256 * If the device has any current volume associated with it,
257 * and it is a different Volume, and the device is not busy,
258 * we release the old Volume item and insert the new one.
260 * It is assumed that the device is free and locked so that
261 * we can change the device structure.
263 * Some details of the Volume list handling:
265 * 1. The Volume list entry must be attached to the drive (rather than
266 * attached to a job as it currently is. I.e. the drive that "owns"
267 * the volume (reserved, in use, mounted)
268 * must point to the volume (still to be maintained in a list).
270 * 2. The Volume is entered in the list when a drive is reserved.
272 * 3. When a drive is in use, the device code must appropriately update the
273 * volume name as it changes (currently the list is static -- an entry is
274 * removed when the Volume is no longer reserved, in use or mounted).
275 * The new code must keep the same list entry as long as the drive
276 * has any volume associated with it but the volume name in the list
277 * must be updated when the drive has a different volume mounted.
279 * 4. A job that has reserved a volume, can un-reserve the volume, and if the
280 * volume is not mounted, and not reserved, and not in use, it will be
281 * removed from the list.
283 * 5. If a job wants to reserve a drive with a different Volume from the one on
284 * the drive, it can re-use the drive for the new Volume.
286 * 6. If a job wants a Volume that is in a different drive, it can either use the
287 * other drive or take the volume, only if the other drive is not in use or
290 * One nice aspect of this is that the reserve use count and the writer use count
291 * already exist and are correctly programmed and will need no changes -- use
292 * counts are always very tricky.
294 * The old code had a concept of "reserving" a Volume, but it needs to be changed
295 * to reserving and using a drive. A volume is must be attached to (owned by) a
296 * drive and can move from drive to drive or be unused given certain specific
297 * conditions of the drive. The key is that the drive must "own" the Volume.
298 * The old code has the job (dcr) owning the volume (more or less). The job is
299 * to change the insertion and removal of the volumes from the list to be based
300 * on the drive rather than the job.
302 * Return: VOLRES entry on success
303 * NULL volume busy on another drive
305 VOLRES *reserve_volume(DCR *dcr, const char *VolumeName)
308 DEVICE *dev = dcr->dev;
312 Dmsg2(dbglvl, "jid=%u reserve_volume %s\n", jid(), VolumeName);
314 * We lock the reservations system here to ensure
315 * when adding a new volume that no newly scheduled
316 * job can reserve it.
319 debug_list_volumes("begin reserve_volume");
321 * First, remove any old volume attached to this device as it
327 * Make sure we don't remove the current volume we are inserting
328 * because it was probably inserted by another job.
330 if (strcmp(vol->vol_name, VolumeName) == 0) {
331 goto get_out; /* Volume already on this device */
333 Dmsg3(dbglvl, "jid=%u reserve_vol free vol=%s at %p\n",
334 (int)dcr->jcr->JobId, vol->vol_name, vol->vol_name);
335 debug_list_volumes("reserve_vol free");
336 vol_list->remove(vol);
341 /* Create a new Volume entry */
342 nvol = new_vol_item(dcr, VolumeName);
345 * Now try to insert the new Volume
347 vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
349 Dmsg3(dbglvl, "jid=%u Found vol=%s dev-same=%d\n", jid(), vol->vol_name, dev==vol->dev);
351 * At this point, a Volume with this name already is in the list,
352 * so we simply release our new Volume entry. Note, this should
353 * only happen if we are moving the volume from one drive to another.
355 Dmsg3(dbglvl, "jid=%u reserve_vol free-tmp vol=%s at %p\n",
356 (int)dcr->jcr->JobId, vol->vol_name, vol->vol_name);
358 * Clear dev pointer so that free_vol_item() doesn't
359 * take away our volume.
361 nvol->dev = NULL; /* don't zap dev entry */
364 /* Check if we are trying to use the Volume on a different drive */
365 if (dev != vol->dev) {
366 /* Caller wants to switch Volume to another device */
367 if (!vol->dev->is_busy()) {
368 /* OK to move it -- I'm not sure this will work */
369 Dmsg4(dbglvl, "==== jid=%u Swap vol=%s from dev=%s to %s\n", jid(), VolumeName,
370 vol->dev->print_name(), dev->print_name());
371 vol->dev->vol = NULL; /* take vol from old drive */
372 vol->dev->VolHdr.VolumeName[0] = 0;
373 vol->dev = dev; /* point vol at new drive */
374 dev->vol = vol; /* point dev at vol */
375 dev->VolHdr.VolumeName[0] = 0;
377 Dmsg4(dbglvl, "jid=%u Volume busy could not swap vol=%s from dev=%s to %s\n",
378 jid(), VolumeName, vol->dev->print_name(), dev->print_name());
379 vol = NULL; /* device busy */
386 debug_list_volumes("end new volume");
392 * Search for a Volume name in the Volume list.
394 * Returns: VOLRES entry on success
395 * NULL if the Volume is not in the list
397 VOLRES *find_volume(DCR *dcr)
400 /* Do not lock reservations here */
402 vol.vol_name = bstrdup(dcr->VolumeName);
403 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
405 Dmsg3(dbglvl, "jid=%u find_vol=%s found=%d\n", jid(), dcr->VolumeName, fvol!=NULL);
406 debug_list_volumes("find_volume");
412 * Remove any reservation from a drive and tell the system
413 * that the volume is unused at least by us.
415 void unreserve_device(DCR *dcr)
417 DEVICE *dev = dcr->dev;
419 if (dcr->reserved_device) {
420 dcr->reserved_device = false;
421 dev->reserved_device--;
422 Dmsg3(dbglvl, "jid=%u Dec reserve=%d dev=%s\n", jid(), dev->reserved_device, dev->print_name());
423 dcr->reserved_device = false;
424 /* If we set read mode in reserving, remove it */
425 if (dev->can_read()) {
428 if (dev->num_writers < 0) {
429 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
430 dev->num_writers = 0;
439 * Free a Volume from the Volume list if it is no longer used
441 * Returns: true if the Volume found and removed from the list
442 * false if the Volume is not in the list or is in use
444 bool volume_unused(DCR *dcr)
446 DEVICE *dev = dcr->dev;
448 if (dev->vol == NULL) {
449 Dmsg2(dbglvl, "jid=%u vol_unused: no vol on %s\n", (int)dcr->jcr->JobId, dev->print_name());
450 debug_list_volumes("null vol cannot unreserve_volume");
454 if (dev->is_busy()) {
455 Dmsg2(dbglvl, "jid=%u vol_unused: no vol on %s\n", (int)dcr->jcr->JobId, dev->print_name());
456 debug_list_volumes("dev busy cannot unreserve_volume");
461 * If this is a tape, we do not free the volume, rather we wait
462 * until the autoloader unloads it, or until another tape is
463 * explicitly read in this drive. This allows the SD to remember
464 * where the tapes are or last were.
466 if (dev->is_tape() || dev->is_autochanger()) {
469 return free_volume(dev);
474 * Unconditionally release the volume
476 bool free_volume(DEVICE *dev)
480 if (dev->vol == NULL) {
481 Dmsg2(dbglvl, "jid=%u No vol on dev %s\n", jid(), dev->print_name());
487 vol_list->remove(vol);
488 Dmsg3(dbglvl, "jid=%u free_volume %s dev=%s\n", jid(), vol->vol_name, dev->print_name());
490 debug_list_volumes("free_volume");
496 /* Create the Volume list */
497 void create_volume_list()
500 if (vol_list == NULL) {
501 vol_list = New(dlist(vol, &vol->link));
505 /* Release all Volumes from the list */
506 void free_volume_list()
513 foreach_dlist(vol, vol_list) {
515 Dmsg3(dbglvl, "jid=%u free vol_list Volume=%s dev=%s\n", jid(),
516 vol->vol_name, vol->dev->print_name());
518 Dmsg3(dbglvl, "jid=%u free vol_list Volume=%s dev=%p\n", jid(),
519 vol->vol_name, vol->dev);
522 vol->vol_name = NULL;
529 bool is_volume_in_use(DCR *dcr)
531 VOLRES *vol = find_volume(dcr);
533 Dmsg2(dbglvl, "jid=%u Vol=%s not in use.\n", jid(), dcr->VolumeName);
534 return false; /* vol not in list */
536 ASSERT(vol->dev != NULL);
538 if (dcr->dev == vol->dev) { /* same device OK */
539 Dmsg2(dbglvl, "jid=%u Vol=%s on same dev.\n", jid(), dcr->VolumeName);
542 Dmsg4(dbglvl, "jid=%u Vol=%s on %s we have %s\n", jid(), dcr->VolumeName,
543 vol->dev->print_name(), dcr->dev->print_name());
545 if (!vol->dev->is_busy()) {
546 Dmsg3(dbglvl, "jid=%u Vol=%s dev=%s not busy.\n", jid(), dcr->VolumeName, vol->dev->print_name());
549 Dmsg3(dbglvl, "jid=%u Vol=%s dev=%s busy.\n", jid(), dcr->VolumeName, vol->dev->print_name());
551 Dmsg3(dbglvl, "jid=%u Vol=%s in use by %s.\n", jid(), dcr->VolumeName, vol->dev->print_name());
557 * We get the following type of information:
559 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
563 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
567 static bool use_storage_cmd(JCR *jcr)
569 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
570 BSOCK *dir = jcr->dir_bsock;
580 memset(&rctx, 0, sizeof(RCTX));
583 * If there are multiple devices, the director sends us
584 * use_device for each device that it wants to use.
586 dirstore = New(alist(10, not_owned_by_alist));
587 msgs = jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
589 Dmsg2(dbglvl, "jid=%u <dird: %s", jid(), dir->msg);
590 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
591 media_type.c_str(), pool_name.c_str(),
592 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
597 jcr->write_store = dirstore;
599 jcr->read_store = dirstore;
601 rctx.append = append;
602 unbash_spaces(store_name);
603 unbash_spaces(media_type);
604 unbash_spaces(pool_name);
605 unbash_spaces(pool_type);
606 store = new DIRSTORE;
607 dirstore->append(store);
608 memset(store, 0, sizeof(DIRSTORE));
609 store->device = New(alist(10));
610 bstrncpy(store->name, store_name, sizeof(store->name));
611 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
612 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
613 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
614 store->append = append;
616 /* Now get all devices */
617 while (dir->recv() >= 0) {
618 Dmsg2(dbglvl, "jid=%u <dird device: %s", jid(), dir->msg);
619 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
623 unbash_spaces(dev_name);
624 store->device->append(bstrdup(dev_name.c_str()));
626 } while (ok && dir->recv() >= 0);
628 /* Developer debug code */
630 if (debug_level >= dbglvl) {
631 foreach_alist(store, dirstore) {
632 Dmsg6(dbglvl, "jid=%u Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
633 (int)rctx.jcr->JobId,
634 store->name, store->media_type, store->pool_name,
635 store->pool_type, store->append);
636 foreach_alist(device_name, store->device) {
637 Dmsg2(dbglvl, "jid=%u Device=%s\n", jid(), device_name);
642 init_jcr_device_wait_timers(jcr);
643 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
645 BSOCK *dir = jcr->dir_bsock;
646 dir->fsend(_("3939 Could not get dcr\n"));
647 Dmsg1(dbglvl, ">dird: %s", dir->msg);
651 * At this point, we have a list of all the Director's Storage
652 * resources indicated for this Job, which include Pool, PoolType,
653 * storage name, and Media type.
654 * Then for each of the Storage resources, we have a list of
655 * device names that were given.
657 * Wiffle through them and find one that can do the backup.
660 int wait_for_device_retries = 0;
663 rctx.notify_dir = true;
666 for ( ; !fail && !job_canceled(jcr); ) {
667 while ((msg = (char *)msgs->pop())) {
670 rctx.suitable_device = false;
671 rctx.have_volume = false;
672 rctx.VolumeName[0] = 0;
673 rctx.any_drive = false;
674 if (!jcr->PreferMountedVols) {
676 * Here we try to find a drive that is not used.
677 * This will maximize the use of available drives.
680 rctx.num_writers = 20000000; /* start with impossible number */
681 rctx.low_use_drive = NULL;
682 rctx.PreferMountedVols = false;
683 rctx.exact_match = false;
684 rctx.autochanger_only = true;
685 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
686 (int)rctx.jcr->JobId,
687 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
688 rctx.autochanger_only, rctx.any_drive);
689 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
692 /* Look through all drives possibly for low_use drive */
693 if (rctx.low_use_drive) {
694 rctx.try_low_use_drive = true;
695 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
698 rctx.try_low_use_drive = false;
700 rctx.autochanger_only = false;
701 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
702 (int)rctx.jcr->JobId,
703 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
704 rctx.autochanger_only, rctx.any_drive);
705 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
710 * Now we look for a drive that may or may not be in
713 /* Look for an exact Volume match all drives */
714 rctx.PreferMountedVols = true;
715 rctx.exact_match = true;
716 rctx.autochanger_only = false;
717 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
718 (int)rctx.jcr->JobId,
719 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
720 rctx.autochanger_only, rctx.any_drive);
721 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
724 /* Look for any mounted drive */
725 rctx.exact_match = false;
726 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
727 (int)rctx.jcr->JobId,
728 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
729 rctx.autochanger_only, rctx.any_drive);
730 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
734 rctx.any_drive = true;
735 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
736 (int)rctx.jcr->JobId,
737 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
738 rctx.autochanger_only, rctx.any_drive);
739 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
742 /* Keep reservations locked *except* during wait_for_device() */
743 unlock_reservations();
745 * The idea of looping on repeat a few times it to ensure
746 * that if there is some subtle timing problem between two
747 * jobs, we will simply try again, and most likely succeed.
748 * This can happen if one job reserves a drive or finishes using
749 * a drive at the same time a second job wants it.
751 if (repeat++ > 1) { /* try algorithm 3 times */
752 bmicrosleep(30, 0); /* wait a bit */
753 Dmsg1(dbglvl, "jid=%u repeat reserve algorithm\n", (int)rctx.jcr->JobId);
754 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
755 Dmsg1(dbglvl, "jid=%u Fail. !suitable_device || !wait_for_device\n",
756 (int)rctx.jcr->JobId);
760 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
762 unlock_reservations();
765 * If we get here, there are no suitable devices available, which
766 * means nothing configured. If a device is suitable but busy
767 * with another Volume, we will not come here.
769 unbash_spaces(dir->msg);
770 pm_strcpy(jcr->errmsg, dir->msg);
771 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
772 Jmsg(jcr, M_FATAL, 0, _("\n"
773 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
774 dev_name.c_str(), media_type.c_str());
775 dir->fsend(NO_device, dev_name.c_str());
777 Dmsg2(dbglvl, "jid=%u >dird: %s", jid(), dir->msg);
780 unbash_spaces(dir->msg);
781 pm_strcpy(jcr->errmsg, dir->msg);
782 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
783 dir->fsend(BAD_use, jcr->errmsg);
784 Dmsg2(dbglvl, "jid=%u >dird: %s", jid(), dir->msg);
791 void release_msgs(JCR *jcr)
793 alist *msgs = jcr->reserve_msgs;
800 while ((msg = (char *)msgs->pop())) {
804 jcr->reserve_msgs = NULL;
805 unlock_reservations();
809 * Walk through the autochanger resources and check if
810 * the volume is in one of them.
812 * Returns: true if volume is in device
815 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
817 AUTOCHANGER *changer;
818 Dmsg2(dbglvl, "jid=%u search changers for %s\n", (int)rctx.jcr->JobId,
820 foreach_res(changer, R_AUTOCHANGER) {
821 Dmsg3(dbglvl, "jid=%u Try match changer res=%s device=%s\n",
822 (int)rctx.jcr->JobId, changer->hdr.name, rctx.device_name);
823 /* Find resource, and make sure we were able to open it */
824 if (fnmatch(rctx.device_name, changer->hdr.name, 0) == 0) {
826 /* Try each device in this AutoChanger */
827 foreach_alist(device, changer->device) {
828 if (device->dev == vol->dev) {
829 Dmsg2(dbglvl, "jid=%u Found changer device %s\n",
830 (int)rctx.jcr->JobId, device->hdr.name);
833 Dmsg2(dbglvl, "jid=%u Incorrect changer device %s\n",
834 (int)rctx.jcr->JobId, device->hdr.name);
842 * Search for a device suitable for this job.
844 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
853 dirstore = jcr->write_store;
855 dirstore = jcr->read_store;
857 Dmsg5(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
858 (int)rctx.jcr->JobId,
859 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
860 rctx.autochanger_only);
863 * If the appropriate conditions of this if are met, namely that
864 * we are appending and the user wants mounted drive (or we
865 * force try a mounted drive because they are all busy), we
866 * start by looking at all the Volumes in the volume list.
868 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
869 dlist *temp_vol_list, *save_vol_list;
874 * Create a temporary copy of the volume list. We do this,
875 * to avoid having the volume list locked during the
876 * call to reserve_device(), which would cause a deadlock.
877 * Note, we may want to add an update counter on the vol_list
878 * so that if it is modified while we are traversing the copy
879 * we can take note and act accordingly (probably redo the
880 * search at least a few times).
882 Dmsg1(dbglvl, "jid=%u duplicate vol list\n", (int)rctx.jcr->JobId);
883 temp_vol_list = New(dlist(vol, &vol->link));
884 foreach_dlist(vol, vol_list) {
886 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
887 memset(tvol, 0, sizeof(VOLRES));
888 tvol->vol_name = bstrdup(vol->vol_name);
889 tvol->dev = vol->dev;
890 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
892 tvol->dev = NULL; /* don't zap dev entry */
894 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
895 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
900 /* Look through reserved volumes for one we can use */
901 Dmsg1(dbglvl, "jid=%u look for vol in vol list\n", (int)rctx.jcr->JobId);
902 foreach_dlist(vol, temp_vol_list) {
904 Dmsg2(dbglvl, "jid=%u vol=%s no dev\n", (int)rctx.jcr->JobId, vol->vol_name);
907 /* Check with Director if this Volume is OK */
908 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
909 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
913 Dmsg2(dbglvl, "jid=%u vol=%s\n", (int)rctx.jcr->JobId, vol->vol_name);
914 foreach_alist(store, dirstore) {
917 foreach_alist(device_name, store->device) {
918 /* Found a device, try to use it */
919 rctx.device_name = device_name;
920 rctx.device = vol->dev->device;
922 if (vol->dev->is_autochanger()) {
923 Dmsg2(dbglvl, "jid=%u vol=%s is in changer\n", (int)rctx.jcr->JobId,
925 if (!is_vol_in_autochanger(rctx, vol)) {
928 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
929 Dmsg3(dbglvl, "jid=%u device=%s not suitable want %s\n", (int)rctx.jcr->JobId,
930 vol->dev->device->hdr.name, device_name);
934 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
935 rctx.have_volume = true;
936 /* Try reserving this device and volume */
937 Dmsg3(dbglvl, "jid=%u try vol=%s on device=%s\n", (int)rctx.jcr->JobId,
938 rctx.VolumeName, device_name);
939 stat = reserve_device(rctx);
940 if (stat == 1) { /* found available device */
941 Dmsg2(dbglvl, "jid=%u Suitable device found=%s\n", (int)rctx.jcr->JobId,
945 } else if (stat == 0) { /* device busy */
946 Dmsg2(dbglvl, "jid=%u Suitable device=%s, busy: not use\n",
947 (int)rctx.jcr->JobId, device_name);
949 /* otherwise error */
950 Dmsg1(dbglvl, "jid=%u No suitable device found.\n", (int)rctx.jcr->JobId);
952 rctx.have_volume = false;
958 } /* end for loop over reserved volumes */
961 save_vol_list = vol_list;
962 vol_list = temp_vol_list;
963 free_volume_list(); /* release temp_vol_list */
964 vol_list = save_vol_list;
965 Dmsg1(dbglvl, "jid=%u deleted temp vol list\n", (int)rctx.jcr->JobId);
969 Dmsg2(dbglvl, "jid=%u got vol %s in reserved volums list\n", (int)rctx.jcr->JobId,
975 * No reserved volume we can use, so now search for an available device.
977 * For each storage device that the user specified, we
978 * search and see if there is a resource for that device.
980 foreach_alist(store, dirstore) {
982 foreach_alist(device_name, store->device) {
984 rctx.device_name = device_name;
985 stat = search_res_for_device(rctx);
986 if (stat == 1) { /* found available device */
987 Dmsg2(dbglvl, "jid=%u available device found=%s\n", (int)rctx.jcr->JobId,
991 } else if (stat == 0) { /* device busy */
992 Dmsg2(dbglvl, "jid=%u Suitable device=%s, busy: not use\n",
993 (int)rctx.jcr->JobId, device_name);
995 /* otherwise error */
996 Dmsg1(dbglvl, "jid=%u No suitable device found.\n", (int)rctx.jcr->JobId);
1007 * Search for a particular storage device with particular storage
1008 * characteristics (MediaType).
1010 int search_res_for_device(RCTX &rctx)
1012 AUTOCHANGER *changer;
1015 Dmsg2(dbglvl, "jid=%u search res for %s\n", (int)rctx.jcr->JobId, rctx.device_name);
1016 /* Look through Autochangers first */
1017 foreach_res(changer, R_AUTOCHANGER) {
1018 Dmsg2(dbglvl, "jid=%u Try match changer res=%s\n", (int)rctx.jcr->JobId, changer->hdr.name);
1019 /* Find resource, and make sure we were able to open it */
1020 if (fnmatch(rctx.device_name, changer->hdr.name, 0) == 0) {
1021 /* Try each device in this AutoChanger */
1022 foreach_alist(rctx.device, changer->device) {
1023 Dmsg2(dbglvl, "jid=%u Try changer device %s\n", (int)rctx.jcr->JobId,
1024 rctx.device->hdr.name);
1025 stat = reserve_device(rctx);
1026 if (stat != 1) { /* try another device */
1030 if (rctx.store->append == SD_APPEND) {
1031 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for append.\n",
1032 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1033 rctx.jcr->dcr->dev->reserved_device);
1035 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for read.\n",
1036 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1037 rctx.jcr->read_dcr->dev->reserved_device);
1044 /* Now if requested look through regular devices */
1045 if (!rctx.autochanger_only) {
1046 foreach_res(rctx.device, R_DEVICE) {
1047 Dmsg2(dbglvl, "jid=%u Try match res=%s\n", (int)rctx.jcr->JobId, rctx.device->hdr.name);
1048 /* Find resource, and make sure we were able to open it */
1049 if (fnmatch(rctx.device_name, rctx.device->hdr.name, 0) == 0) {
1050 stat = reserve_device(rctx);
1051 if (stat != 1) { /* try another device */
1055 if (rctx.store->append == SD_APPEND) {
1056 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for append.\n",
1057 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1058 rctx.jcr->dcr->dev->reserved_device);
1060 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for read.\n",
1061 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1062 rctx.jcr->read_dcr->dev->reserved_device);
1068 return -1; /* nothing found */
1072 * Try to reserve a specific device.
1074 * Returns: 1 -- OK, have DCR
1078 static int reserve_device(RCTX &rctx)
1082 const int name_len = MAX_NAME_LENGTH;
1084 /* Make sure MediaType is OK */
1085 Dmsg3(dbglvl, "jid=%u chk MediaType device=%s request=%s\n",
1086 (int)rctx.jcr->JobId,
1087 rctx.device->media_type, rctx.store->media_type);
1088 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1092 /* Make sure device exists -- i.e. we can stat() it */
1093 if (!rctx.device->dev) {
1094 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1096 if (!rctx.device->dev) {
1097 if (rctx.device->changer_res) {
1098 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1099 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1100 rctx.device->hdr.name, rctx.device_name);
1102 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1103 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1106 return -1; /* no use waiting */
1109 rctx.suitable_device = true;
1110 Dmsg2(dbglvl, "jid=%u try reserve %s\n", rctx.jcr->JobId, rctx.device->hdr.name);
1111 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1113 BSOCK *dir = rctx.jcr->dir_bsock;
1114 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1115 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1118 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1119 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1120 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1121 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1122 if (rctx.store->append == SD_APPEND) {
1123 Dmsg3(dbglvl, "jid=%u have_vol=%d vol=%s\n", (int)rctx.jcr->JobId,
1124 rctx.have_volume, rctx.VolumeName);
1125 ok = reserve_device_for_append(dcr, rctx);
1130 rctx.jcr->dcr = dcr;
1131 Dmsg6(dbglvl, "jid=%u Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1132 (int)rctx.jcr->JobId,
1133 dcr->dev->reserved_device,
1134 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1135 if (!rctx.have_volume) {
1136 dcr->any_volume = true;
1137 if (dir_find_next_appendable_volume(dcr)) {
1138 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1139 Dmsg2(dbglvl, "jid=%u looking for Volume=%s\n", (int)rctx.jcr->JobId, rctx.VolumeName);
1140 rctx.have_volume = true;
1142 Dmsg1(dbglvl, "jid=%u No next volume found\n", (int)rctx.jcr->JobId);
1143 rctx.have_volume = false;
1144 rctx.VolumeName[0] = 0;
1146 * If there is at least one volume that is valid and in use,
1147 * but we get here, check if we are running with prefers
1148 * non-mounted drives. In that case, we have selected a
1149 * non-used drive and our one and only volume is mounted
1150 * elsewhere, so we bail out and retry using that drive.
1152 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1153 rctx.PreferMountedVols = true;
1159 ok = reserve_device_for_read(dcr);
1161 rctx.jcr->read_dcr = dcr;
1162 Dmsg6(dbglvl, "jid=%u Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1163 (int)rctx.jcr->JobId,
1164 dcr->dev->reserved_device,
1165 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1171 if (rctx.notify_dir) {
1173 BSOCK *dir = rctx.jcr->dir_bsock;
1174 pm_strcpy(dev_name, rctx.device->hdr.name);
1175 bash_spaces(dev_name);
1176 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1177 Dmsg2(dbglvl, "jid=%u >dird changer: %s", jid(), dir->msg);
1184 rctx.have_volume = false;
1186 Dmsg1(dbglvl, "jid=%u Not OK.\n", (int)rctx.jcr->JobId);
1191 * We "reserve" the drive by setting the ST_READ bit. No one else
1192 * should touch the drive until that is cleared.
1193 * This allows the DIR to "reserve" the device before actually
1196 static bool reserve_device_for_read(DCR *dcr)
1198 DEVICE *dev = dcr->dev;
1199 JCR *jcr = dcr->jcr;
1206 if (is_device_unmounted(dev)) {
1207 Dmsg2(dbglvl, "jid=%u Device %s is BLOCKED due to user unmount.\n",
1208 (int)jcr->JobId, dev->print_name());
1209 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1210 jcr->JobId, dev->print_name());
1211 queue_reserve_message(jcr);
1215 if (dev->is_busy()) {
1216 Dmsg5(dbglvl, "jid=%u Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1217 (int)jcr->JobId, dev->print_name(),
1218 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1219 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1220 jcr->JobId, dev->print_name());
1221 queue_reserve_message(jcr);
1225 dev->clear_append();
1228 dev->reserved_device++;
1229 Dmsg4(dbglvl, "jid=%u Inc reserve=%d dev=%s %p\n", (int)jcr->JobId,
1230 dev->reserved_device, dev->print_name(), dev);
1231 dcr->reserved_device = true;
1240 * We reserve the device for appending by incrementing the
1241 * reserved_device. We do virtually all the same work that
1242 * is done in acquire_device_for_append(), but we do
1243 * not attempt to mount the device. This routine allows
1244 * the DIR to reserve multiple devices before *really*
1245 * starting the job. It also permits the SD to refuse
1246 * certain devices (not up, ...).
1248 * Note, in reserving a device, if the device is for the
1249 * same pool and the same pool type, then it is acceptable.
1250 * The Media Type has already been checked. If we are
1251 * the first tor reserve the device, we put the pool
1252 * name and pool type in the device record.
1254 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1256 JCR *jcr = dcr->jcr;
1257 DEVICE *dev = dcr->dev;
1264 /* If device is being read, we cannot write it */
1265 if (dev->can_read()) {
1266 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1267 jcr->JobId, dev->print_name());
1268 Dmsg2(dbglvl, "jid=%u %s", jid(), jcr->errmsg);
1269 queue_reserve_message(jcr);
1273 /* If device is unmounted, we are out of luck */
1274 if (is_device_unmounted(dev)) {
1275 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1276 jcr->JobId, dev->print_name());
1277 Dmsg2(dbglvl, "jid=%u %s", jid(), jcr->errmsg);
1278 queue_reserve_message(jcr);
1282 Dmsg2(dbglvl, "jid=%u reserve_append device is %s\n",
1283 (int)jcr->JobId, dev->print_name());
1285 /* Now do detailed tests ... */
1286 if (can_reserve_drive(dcr, rctx) != 1) {
1287 Dmsg1(dbglvl, "jid=%u can_reserve_drive!=1\n", (int)jcr->JobId);
1291 dev->reserved_device++;
1292 Dmsg4(dbglvl, "jid=%u Inc reserve=%d dev=%s %p\n", (int)jcr->JobId, dev->reserved_device,
1293 dev->print_name(), dev);
1294 dcr->reserved_device = true;
1303 * Returns: 1 if drive can be reserved
1304 * 0 if we should wait
1305 * -1 on error or impossibility
1307 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1309 DEVICE *dev = dcr->dev;
1310 JCR *jcr = dcr->jcr;
1312 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1314 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1315 rctx.autochanger_only, rctx.any_drive);
1317 /* setting any_drive overrides PreferMountedVols flag */
1318 if (!rctx.any_drive) {
1320 * When PreferMountedVols is set, we keep track of the
1321 * drive in use that has the least number of writers, then if
1322 * no unmounted drive is found, we try that drive. This
1323 * helps spread the load to the least used drives.
1325 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1326 Dmsg3(dbglvl, "jid=%u OK dev=%s == low_drive=%s.\n",
1327 jcr->JobId, dev->print_name(), rctx.low_use_drive->print_name());
1330 /* If he wants a free drive, but this one is busy, no go */
1331 if (!rctx.PreferMountedVols && dev->is_busy()) {
1332 /* Save least used drive */
1333 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1334 rctx.num_writers = dev->num_writers + dev->reserved_device;
1335 rctx.low_use_drive = dev;
1336 Dmsg3(dbglvl, "jid=%u set low use drive=%s num_writers=%d\n",
1337 (int)jcr->JobId, dev->print_name(), rctx.num_writers);
1339 Dmsg2(dbglvl, "jid=%u not low use num_writers=%d\n",
1340 (int)jcr->JobId, dev->num_writers+dev->reserved_device);
1342 Dmsg1(dbglvl, "jid=%u failed: !prefMnt && busy.\n", jcr->JobId);
1343 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1344 jcr->JobId, dev->print_name());
1345 queue_reserve_message(jcr);
1349 /* Check for prefer mounted volumes */
1350 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1351 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1352 jcr->JobId, dev->print_name());
1353 queue_reserve_message(jcr);
1354 Dmsg1(dbglvl, "jid=%u failed: want mounted -- no vol\n", (uint32_t)jcr->JobId);
1355 return 0; /* No volume mounted */
1358 /* Check for exact Volume name match */
1359 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1362 if (rctx.exact_match && rctx.have_volume) {
1364 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1366 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1367 rctx.autochanger_only, rctx.any_drive);
1368 Dmsg5(dbglvl, "jid=%u have_vol=%d have=%s resvol=%s want=%s\n",
1369 (int)jcr->JobId, rctx.have_volume, dev->VolHdr.VolumeName,
1370 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1371 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1372 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1374 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1375 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1377 queue_reserve_message(jcr);
1378 Dmsg4(dbglvl, "jid=%u not OK: dev have=%s resvol=%s want=%s\n",
1379 (int)jcr->JobId, dev->VolHdr.VolumeName,
1380 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1383 if (is_volume_in_use(dcr)) {
1384 return 0; /* fail if volume on another drive */
1389 /* Check for unused autochanger drive */
1390 if (rctx.autochanger_only && !dev->is_busy() &&
1391 dev->VolHdr.VolumeName[0] == 0) {
1392 /* Device is available but not yet reserved, reserve it for us */
1393 Dmsg2(dbglvl, "jid=%u OK Res Unused autochanger %s.\n",
1394 jcr->JobId, dev->print_name());
1395 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1396 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1397 return 1; /* reserve drive */
1401 * Handle the case that there are no writers
1403 if (dev->num_writers == 0) {
1404 /* Now check if there are any reservations on the drive */
1405 if (dev->reserved_device) {
1406 /* Now check if we want the same Pool and pool type */
1407 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1408 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1409 /* OK, compatible device */
1410 Dmsg2(dbglvl, "jid=%u OK dev: %s num_writers=0, reserved, pool matches\n",
1411 jcr->JobId, dev->print_name());
1414 /* Drive Pool not suitable for us */
1415 Mmsg(jcr->errmsg, _(
1416 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1417 jcr->JobId, dcr->pool_name, dev->pool_name,
1418 dev->reserved_device, dev->print_name());
1419 queue_reserve_message(jcr);
1420 Dmsg3(dbglvl, "jid=%u failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1421 (int)jcr->JobId, dev->pool_name, dcr->pool_name);
1422 return 0; /* wait */
1424 } else if (dev->can_append()) {
1425 /* Device in append mode, check if changing pool */
1426 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1427 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1428 Dmsg2(dbglvl, "jid=%u OK dev: %s num_writers=0, can_append, pool matches.\n",
1429 jcr->JobId, dev->print_name());
1430 /* OK, compatible device */
1433 /* Changing pool, unload old tape if any in drive */
1434 Dmsg1(dbglvl, "jid=%u OK dev: num_writers=0, not reserved, pool change, unload changer\n",
1436 unload_autochanger(dcr, 0);
1439 /* Device is available but not yet reserved, reserve it for us */
1440 Dmsg2(dbglvl, "jid=%u OK Dev avail reserved %s\n", jcr->JobId, dev->print_name());
1441 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1442 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1443 return 1; /* reserve drive */
1447 * Check if the device is in append mode with writers (i.e.
1448 * available if pool is the same).
1450 if (dev->can_append() || dev->num_writers > 0) {
1451 /* Yes, now check if we want the same Pool and pool type */
1452 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1453 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1454 Dmsg2(dbglvl, "jid=%u OK dev: %s num_writers>=0, can_append, pool matches.\n",
1455 jcr->JobId, dev->print_name());
1456 /* OK, compatible device */
1459 /* Drive Pool not suitable for us */
1460 Mmsg(jcr->errmsg, _("3609 JobId=%u wants Pool=\"%s\" but has Pool=\"%s\" on drive %s.\n"),
1461 jcr->JobId, dcr->pool_name, dev->pool_name, dev->print_name());
1462 queue_reserve_message(jcr);
1463 Dmsg3(dbglvl, "jid=%u failed: busy num_writers>0, can_append, pool=%s wanted=%s\n",
1464 (int)jcr->JobId, dev->pool_name, dcr->pool_name);
1465 return 0; /* wait */
1468 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1469 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1470 jcr->JobId, dev->print_name());
1471 queue_reserve_message(jcr);
1472 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1473 return -1; /* error, should not get here */
1475 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1476 jcr->JobId, dev->print_name());
1477 queue_reserve_message(jcr);
1478 Dmsg2(dbglvl, "jid=%u failed: No reserve %s\n", jcr->JobId, dev->print_name());
1483 * search_lock is already set on entering this routine
1485 static void queue_reserve_message(JCR *jcr)
1488 alist *msgs = jcr->reserve_msgs;
1495 * Look for duplicate message. If found, do
1498 for (i=msgs->size()-1; i >= 0; i--) {
1499 msg = (char *)msgs->get(i);
1503 /* Comparison based on 4 digit message number */
1504 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1508 /* Message unique, so insert it */
1509 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1513 * Send any reservation messages queued for this jcr
1515 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1521 lock_reservations();
1522 msgs = jcr->reserve_msgs;
1523 if (!msgs || msgs->size() == 0) {
1526 for (i=msgs->size()-1; i >= 0; i--) {
1527 msg = (char *)msgs->get(i);
1529 sendit(" ", 3, arg);
1530 sendit(msg, strlen(msg), arg);
1537 unlock_reservations();