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 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 void init_reservations_lock()
89 if ((errstat=rwl_init(&reservation_lock)) != 0) {
91 Emsg1(M_ABORT, 0, _("Unable to initialize reservation lock. ERR=%s\n"),
92 be.bstrerror(errstat));
95 if ((errstat=rwl_init(&vol_list_lock)) != 0) {
97 Emsg1(M_ABORT, 0, _("Unable to initialize volume list lock. ERR=%s\n"),
98 be.bstrerror(errstat));
102 void term_reservations_lock()
104 rwl_destroy(&reservation_lock);
105 rwl_destroy(&vol_list_lock);
108 int reservations_lock_count = 0;
110 /* This applies to a drive and to Volumes */
111 void _lock_reservations()
114 reservations_lock_count++;
115 if ((errstat=rwl_writelock(&reservation_lock)) != 0) {
117 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
118 errstat, be.bstrerror(errstat));
122 void _unlock_reservations()
125 reservations_lock_count--;
126 if ((errstat=rwl_writeunlock(&reservation_lock)) != 0) {
128 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
129 errstat, be.bstrerror(errstat));
133 int vol_list_lock_count = 0;
138 vol_list_lock_count++;
139 if ((errstat=rwl_writelock(&vol_list_lock)) != 0) {
141 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
142 errstat, be.bstrerror(errstat));
146 void _unlock_volumes()
149 vol_list_lock_count--;
150 if ((errstat=rwl_writeunlock(&vol_list_lock)) != 0) {
152 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
153 errstat, be.bstrerror(errstat));
159 * List Volumes -- this should be moved to status.c
166 static void debug_list_volumes(const char *imsg)
169 POOL_MEM msg(PM_MESSAGE);
172 foreach_dlist(vol, vol_list) {
174 Mmsg(msg, "List from %s: %s at %p on device %s\n", imsg,
175 vol->vol_name, vol->vol_name, vol->dev->print_name());
177 Mmsg(msg, "List from %s: %s at %p no dev\n", imsg, vol->vol_name, vol->vol_name);
179 Dmsg1(dbglvl, "%s", msg.c_str());
184 foreach_dlist(vol, vol_list) {
185 if (vol->dev == dev) {
186 Dmsg0(dbglvl, "Two Volumes on same device.\n");
193 // Dmsg2(dbglvl, "List from %s: %d volumes\n", imsg, count);
199 * List Volumes -- this should be moved to status.c
201 void list_volumes(void sendit(const char *msg, int len, void *sarg), void *arg)
204 POOL_MEM msg(PM_MESSAGE);
208 foreach_dlist(vol, vol_list) {
209 DEVICE *dev = vol->dev;
211 len = Mmsg(msg, "%s on device %s\n", vol->vol_name, dev->print_name());
212 sendit(msg.c_str(), len, arg);
213 len = Mmsg(msg, " Reader=%d writers=%d reserved=%d released=%d\n",
214 dev->can_read()?1:0, dev->num_writers, dev->reserved_device, vol->released);
215 sendit(msg.c_str(), len, arg);
217 len = Mmsg(msg, "%s no device. released=%d\n", vol->vol_name, vol->released);
218 sendit(msg.c_str(), len, arg);
225 * Create a Volume item to put in the Volume list
226 * Ensure that the device points to it.
228 static VOLRES *new_vol_item(DCR *dcr, const char *VolumeName)
231 vol = (VOLRES *)malloc(sizeof(VOLRES));
232 memset(vol, 0, sizeof(VOLRES));
233 vol->vol_name = bstrdup(VolumeName);
235 Dmsg3(dbglvl, "new Vol=%s at %p dev=%s\n",
236 VolumeName, vol->vol_name, vol->dev->print_name());
240 static void free_vol_item(VOLRES *vol)
244 vol->dev->vol = NULL;
251 * Put a new Volume entry in the Volume list. This
252 * effectively reserves the volume so that it will
253 * not be mounted again.
255 * If the device has any current volume associated with it,
256 * and it is a different Volume, and the device is not busy,
257 * we release the old Volume item and insert the new one.
259 * It is assumed that the device is free and locked so that
260 * we can change the device structure.
262 * Some details of the Volume list handling:
264 * 1. The Volume list entry must be attached to the drive (rather than
265 * attached to a job as it currently is. I.e. the drive that "owns"
266 * the volume (reserved, in use, mounted)
267 * must point to the volume (still to be maintained in a list).
269 * 2. The Volume is entered in the list when a drive is reserved.
271 * 3. When a drive is in use, the device code must appropriately update the
272 * volume name as it changes (currently the list is static -- an entry is
273 * removed when the Volume is no longer reserved, in use or mounted).
274 * The new code must keep the same list entry as long as the drive
275 * has any volume associated with it but the volume name in the list
276 * must be updated when the drive has a different volume mounted.
278 * 4. A job that has reserved a volume, can un-reserve the volume, and if the
279 * volume is not mounted, and not reserved, and not in use, it will be
280 * removed from the list.
282 * 5. If a job wants to reserve a drive with a different Volume from the one on
283 * the drive, it can re-use the drive for the new Volume.
285 * 6. If a job wants a Volume that is in a different drive, it can either use the
286 * other drive or take the volume, only if the other drive is not in use or
289 * One nice aspect of this is that the reserve use count and the writer use count
290 * already exist and are correctly programmed and will need no changes -- use
291 * counts are always very tricky.
293 * The old code had a concept of "reserving" a Volume, but was changed
294 * to reserving and using a drive. A volume is must be attached to (owned by) a
295 * drive and can move from drive to drive or be unused given certain specific
296 * conditions of the drive. The key is that the drive must "own" the Volume.
297 * The old code had the job (dcr) owning the volume (more or less). The job was
298 * to change the insertion and removal of the volumes from the list to be based
299 * on the drive rather than the job.
301 * Return: VOLRES entry on success
302 * NULL volume busy on another drive
304 VOLRES *reserve_volume(DCR *dcr, const char *VolumeName)
307 DEVICE *dev = dcr->dev;
311 Dmsg1(dbglvl, "reserve_volume %s\n", VolumeName);
313 * We lock the reservations system here to ensure
314 * when adding a new volume that no newly scheduled
315 * job can reserve it.
318 debug_list_volumes("begin reserve_volume");
320 * First, remove any old volume attached to this device as it
326 * Make sure we don't remove the current volume we are inserting
327 * because it was probably inserted by another job.
329 if (strcmp(vol->vol_name, VolumeName) == 0) {
330 Dmsg1(dbglvl, "OK, vol=%s on device.\n", VolumeName);
331 goto get_out; /* Volume already on this device */
333 Dmsg2(dbglvl, "reserve_vol free vol=%s at %p\n",
334 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 Dmsg2(dbglvl, "Found vol=%s dev-same=%d\n", 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 Dmsg2(dbglvl, "reserve_vol free-tmp vol=%s at %p\n",
356 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 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n", 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 Dmsg3(dbglvl, "Volume busy could not swap vol=%s from dev=%s to %s\n",
378 VolumeName, vol->dev->print_name(), dev->print_name());
379 vol = NULL; /* device busy */
388 vol->released = false;
390 debug_list_volumes("end new volume");
396 * Search for a Volume name in the Volume list.
398 * Returns: VOLRES entry on success
399 * NULL if the Volume is not in the list
401 VOLRES *find_volume(DCR *dcr)
404 /* Do not lock reservations here */
406 vol.vol_name = bstrdup(dcr->VolumeName);
407 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
409 Dmsg2(dbglvl, "find_vol=%s found=%d\n", dcr->VolumeName, fvol!=NULL);
410 debug_list_volumes("find_volume");
416 * Remove any reservation from a drive and tell the system
417 * that the volume is unused at least by us.
419 void unreserve_device(DCR *dcr)
421 DEVICE *dev = dcr->dev;
422 if (dcr->reserved_device) {
423 dcr->reserved_device = false;
424 dev->reserved_device--;
425 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name());
426 dcr->reserved_device = false;
427 /* If we set read mode in reserving, remove it */
428 if (dev->can_read()) {
431 if (dev->num_writers < 0) {
432 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
433 dev->num_writers = 0;
441 * Free a Volume from the Volume list if it is no longer used
443 * Returns: true if the Volume found and removed from the list
444 * false if the Volume is not in the list or is in use
446 bool volume_unused(DCR *dcr)
448 DEVICE *dev = dcr->dev;
450 if (dev->vol == NULL) {
451 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
452 debug_list_volumes("null vol cannot unreserve_volume");
456 if (dev->is_busy()) {
457 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
458 debug_list_volumes("dev busy cannot unreserve_volume");
463 * If this is a tape, we do not free the volume, rather we wait
464 * until the autoloader unloads it, or until another tape is
465 * explicitly read in this drive. This allows the SD to remember
466 * where the tapes are or last were.
468 dev->vol->released = true;
469 if (dev->is_tape() || dev->is_autochanger()) {
472 return free_volume(dev);
477 * Unconditionally release the volume
479 bool free_volume(DEVICE *dev)
483 if (dev->vol == NULL) {
484 Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name());
490 vol_list->remove(vol);
491 Dmsg2(dbglvl, "free_volume %s dev=%s\n", vol->vol_name, dev->print_name());
493 debug_list_volumes("free_volume");
499 /* Create the Volume list */
500 void create_volume_list()
503 if (vol_list == NULL) {
504 vol_list = New(dlist(vol, &vol->link));
508 /* Release all Volumes from the list */
509 void free_volume_list()
516 foreach_dlist(vol, vol_list) {
518 Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name());
520 Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name);
523 vol->vol_name = NULL;
530 bool is_volume_in_use(DCR *dcr)
532 VOLRES *vol = find_volume(dcr);
534 Dmsg1(dbglvl, "Vol=%s not in use.\n", dcr->VolumeName);
535 return false; /* vol not in list */
537 ASSERT(vol->dev != NULL);
539 if (dcr->dev == vol->dev) { /* same device OK */
540 Dmsg1(dbglvl, "Vol=%s on same dev.\n", dcr->VolumeName);
543 Dmsg3(dbglvl, "Vol=%s on %s we have %s\n", dcr->VolumeName,
544 vol->dev->print_name(), dcr->dev->print_name());
546 if (!vol->dev->is_busy()) {
547 Dmsg2(dbglvl, "Vol=%s dev=%s not busy.\n", dcr->VolumeName, vol->dev->print_name());
550 Dmsg2(dbglvl, "Vol=%s dev=%s busy.\n", dcr->VolumeName, vol->dev->print_name());
552 Dmsg2(dbglvl, "Vol=%s in use by %s.\n", dcr->VolumeName, vol->dev->print_name());
558 * We get the following type of information:
560 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
564 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
568 static bool use_storage_cmd(JCR *jcr)
570 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
571 BSOCK *dir = jcr->dir_bsock;
579 memset(&rctx, 0, sizeof(RCTX));
582 * If there are multiple devices, the director sends us
583 * use_device for each device that it wants to use.
585 dirstore = New(alist(10, not_owned_by_alist));
586 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
588 Dmsg1(dbglvl, "<dird: %s", dir->msg);
589 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
590 media_type.c_str(), pool_name.c_str(),
591 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
596 jcr->write_store = dirstore;
598 jcr->read_store = dirstore;
600 rctx.append = append;
601 unbash_spaces(store_name);
602 unbash_spaces(media_type);
603 unbash_spaces(pool_name);
604 unbash_spaces(pool_type);
605 store = new DIRSTORE;
606 dirstore->append(store);
607 memset(store, 0, sizeof(DIRSTORE));
608 store->device = New(alist(10));
609 bstrncpy(store->name, store_name, sizeof(store->name));
610 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
611 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
612 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
613 store->append = append;
615 /* Now get all devices */
616 while (dir->recv() >= 0) {
617 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
618 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
622 unbash_spaces(dev_name);
623 store->device->append(bstrdup(dev_name.c_str()));
625 } while (ok && dir->recv() >= 0);
627 /* Developer debug code */
629 if (debug_level >= dbglvl) {
630 foreach_alist(store, dirstore) {
631 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
632 store->name, store->media_type, store->pool_name,
633 store->pool_type, store->append);
634 foreach_alist(device_name, store->device) {
635 Dmsg1(dbglvl, " Device=%s\n", device_name);
640 init_jcr_device_wait_timers(jcr);
641 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
643 BSOCK *dir = jcr->dir_bsock;
644 dir->fsend(_("3939 Could not get dcr\n"));
645 Dmsg1(dbglvl, ">dird: %s", dir->msg);
649 * At this point, we have a list of all the Director's Storage
650 * resources indicated for this Job, which include Pool, PoolType,
651 * storage name, and Media type.
652 * Then for each of the Storage resources, we have a list of
653 * device names that were given.
655 * Wiffle through them and find one that can do the backup.
658 int wait_for_device_retries = 0;
661 rctx.notify_dir = true;
664 for ( ; !fail && !job_canceled(jcr); ) {
665 pop_reserve_messages(jcr);
666 rctx.suitable_device = false;
667 rctx.have_volume = false;
668 rctx.VolumeName[0] = 0;
669 rctx.any_drive = false;
670 if (!jcr->PreferMountedVols) {
672 * Here we try to find a drive that is not used.
673 * This will maximize the use of available drives.
676 rctx.num_writers = 20000000; /* start with impossible number */
677 rctx.low_use_drive = NULL;
678 rctx.PreferMountedVols = false;
679 rctx.exact_match = false;
680 rctx.autochanger_only = true;
681 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
682 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
683 rctx.autochanger_only, rctx.any_drive);
684 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
687 /* Look through all drives possibly for low_use drive */
688 if (rctx.low_use_drive) {
689 rctx.try_low_use_drive = true;
690 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
693 rctx.try_low_use_drive = false;
695 rctx.autochanger_only = false;
696 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
697 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
698 rctx.autochanger_only, rctx.any_drive);
699 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
704 * Now we look for a drive that may or may not be in
707 /* Look for an exact Volume match all drives */
708 rctx.PreferMountedVols = true;
709 rctx.exact_match = true;
710 rctx.autochanger_only = false;
711 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
712 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
713 rctx.autochanger_only, rctx.any_drive);
714 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
717 /* Look for any mounted drive */
718 rctx.exact_match = false;
719 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
720 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
721 rctx.autochanger_only, rctx.any_drive);
722 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
726 rctx.any_drive = true;
727 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
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))) {
733 /* Keep reservations locked *except* during wait_for_device() */
734 unlock_reservations();
736 * The idea of looping on repeat a few times it to ensure
737 * that if there is some subtle timing problem between two
738 * jobs, we will simply try again, and most likely succeed.
739 * This can happen if one job reserves a drive or finishes using
740 * a drive at the same time a second job wants it.
742 if (repeat++ > 1) { /* try algorithm 3 times */
743 bmicrosleep(30, 0); /* wait a bit */
744 Dmsg0(dbglvl, "repeat reserve algorithm\n");
745 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
746 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
750 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
752 unlock_reservations();
755 * If we get here, there are no suitable devices available, which
756 * means nothing configured. If a device is suitable but busy
757 * with another Volume, we will not come here.
759 unbash_spaces(dir->msg);
760 pm_strcpy(jcr->errmsg, dir->msg);
761 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
762 Jmsg(jcr, M_FATAL, 0, _("\n"
763 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
764 dev_name.c_str(), media_type.c_str());
765 dir->fsend(NO_device, dev_name.c_str());
767 Dmsg1(dbglvl, ">dird: %s", dir->msg);
770 unbash_spaces(dir->msg);
771 pm_strcpy(jcr->errmsg, dir->msg);
772 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
773 dir->fsend(BAD_use, jcr->errmsg);
774 Dmsg1(dbglvl, ">dird: %s", dir->msg);
777 release_reserve_messages(jcr);
783 * Walk through the autochanger resources and check if
784 * the volume is in one of them.
786 * Returns: true if volume is in device
789 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
791 AUTOCHANGER *changer = vol->dev->device->changer_res;
793 /* Find resource, and make sure we were able to open it */
794 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
795 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
798 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
803 * Search for a device suitable for this job.
805 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
814 dirstore = jcr->write_store;
816 dirstore = jcr->read_store;
818 Dmsg4(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
819 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
820 rctx.autochanger_only);
823 * If the appropriate conditions of this if are met, namely that
824 * we are appending and the user wants mounted drive (or we
825 * force try a mounted drive because they are all busy), we
826 * start by looking at all the Volumes in the volume list.
828 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
829 dlist *temp_vol_list, *save_vol_list;
832 Dmsg0(dbglvl, "lock volumes\n");
835 * Create a temporary copy of the volume list. We do this,
836 * to avoid having the volume list locked during the
837 * call to reserve_device(), which would cause a deadlock.
838 * Note, we may want to add an update counter on the vol_list
839 * so that if it is modified while we are traversing the copy
840 * we can take note and act accordingly (probably redo the
841 * search at least a few times).
843 Dmsg0(dbglvl, "duplicate vol list\n");
844 temp_vol_list = New(dlist(vol, &vol->link));
845 foreach_dlist(vol, vol_list) {
847 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
848 memset(tvol, 0, sizeof(VOLRES));
849 tvol->vol_name = bstrdup(vol->vol_name);
850 tvol->dev = vol->dev;
851 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
853 tvol->dev = NULL; /* don't zap dev entry */
855 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
856 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
859 Dmsg0(dbglvl, "unlock volumes\n");
862 /* Look through reserved volumes for one we can use */
863 Dmsg0(dbglvl, "look for vol in vol list\n");
864 foreach_dlist(vol, temp_vol_list) {
866 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
869 /* Check with Director if this Volume is OK */
870 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
871 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
875 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
876 foreach_alist(store, dirstore) {
879 foreach_alist(device_name, store->device) {
880 /* Found a device, try to use it */
881 rctx.device_name = device_name;
882 rctx.device = vol->dev->device;
884 if (vol->dev->is_autochanger()) {
885 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
886 if (!is_vol_in_autochanger(rctx, vol)) {
889 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
890 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
891 vol->dev->device->hdr.name, device_name);
895 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
896 rctx.have_volume = true;
897 /* Try reserving this device and volume */
898 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
899 stat = reserve_device(rctx);
900 if (stat == 1) { /* found available device */
901 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
904 } else if (stat == 0) { /* device busy */
905 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
907 /* otherwise error */
908 Dmsg0(dbglvl, "No suitable device found.\n");
910 rctx.have_volume = false;
919 } /* end for loop over reserved volumes */
921 Dmsg0(dbglvl, "lock volumes\n");
923 save_vol_list = vol_list;
924 vol_list = temp_vol_list;
925 free_volume_list(); /* release temp_vol_list */
926 vol_list = save_vol_list;
927 Dmsg0(dbglvl, "deleted temp vol list\n");
928 Dmsg0(dbglvl, "lock volumes\n");
932 Dmsg1(dbglvl, "got vol %s from in-use vols list\n", rctx.VolumeName);
937 * No reserved volume we can use, so now search for an available device.
939 * For each storage device that the user specified, we
940 * search and see if there is a resource for that device.
942 foreach_alist(store, dirstore) {
944 foreach_alist(device_name, store->device) {
946 rctx.device_name = device_name;
947 stat = search_res_for_device(rctx);
948 if (stat == 1) { /* found available device */
949 Dmsg1(dbglvl, "available device found=%s\n", device_name);
952 } else if (stat == 0) { /* device busy */
953 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
955 /* otherwise error */
956 Dmsg0(dbglvl, "No suitable device found.\n");
967 * Search for a particular storage device with particular storage
968 * characteristics (MediaType).
970 int search_res_for_device(RCTX &rctx)
972 AUTOCHANGER *changer;
975 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
976 /* Look through Autochangers first */
977 foreach_res(changer, R_AUTOCHANGER) {
978 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
979 /* Find resource, and make sure we were able to open it */
980 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
981 /* Try each device in this AutoChanger */
982 foreach_alist(rctx.device, changer->device) {
983 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
984 stat = reserve_device(rctx);
985 if (stat != 1) { /* try another device */
989 if (rctx.store->append == SD_APPEND) {
990 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
991 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
993 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
994 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1001 /* Now if requested look through regular devices */
1002 if (!rctx.autochanger_only) {
1003 foreach_res(rctx.device, R_DEVICE) {
1004 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
1005 /* Find resource, and make sure we were able to open it */
1006 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1007 stat = reserve_device(rctx);
1008 if (stat != 1) { /* try another device */
1012 if (rctx.store->append == SD_APPEND) {
1013 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1014 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1016 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1017 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1023 return -1; /* nothing found */
1027 * Try to reserve a specific device.
1029 * Returns: 1 -- OK, have DCR
1033 static int reserve_device(RCTX &rctx)
1037 const int name_len = MAX_NAME_LENGTH;
1039 /* Make sure MediaType is OK */
1040 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
1041 rctx.device->media_type, rctx.store->media_type);
1042 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1046 /* Make sure device exists -- i.e. we can stat() it */
1047 if (!rctx.device->dev) {
1048 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1050 if (!rctx.device->dev) {
1051 if (rctx.device->changer_res) {
1052 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1053 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1054 rctx.device->hdr.name, rctx.device_name);
1056 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1057 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1060 return -1; /* no use waiting */
1063 rctx.suitable_device = true;
1064 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1065 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1067 BSOCK *dir = rctx.jcr->dir_bsock;
1068 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1069 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1072 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1073 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1074 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1075 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1076 if (rctx.store->append == SD_APPEND) {
1077 Dmsg2(dbglvl, "have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
1078 ok = reserve_device_for_append(dcr, rctx);
1083 rctx.jcr->dcr = dcr;
1084 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1085 dcr->dev->reserved_device,
1086 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1087 if (!rctx.have_volume) {
1088 dcr->any_volume = true;
1089 if (dir_find_next_appendable_volume(dcr)) {
1090 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1091 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
1092 rctx.have_volume = true;
1094 Dmsg0(dbglvl, "No next volume found\n");
1095 rctx.have_volume = false;
1096 rctx.VolumeName[0] = 0;
1098 * If there is at least one volume that is valid and in use,
1099 * but we get here, check if we are running with prefers
1100 * non-mounted drives. In that case, we have selected a
1101 * non-used drive and our one and only volume is mounted
1102 * elsewhere, so we bail out and retry using that drive.
1104 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1105 rctx.PreferMountedVols = true;
1106 if (dcr->VolumeName[0]) {
1112 * Note. Under some circumstances, the Director can hand us
1113 * a Volume name that is no the same as the one on the current
1114 * drive, and in that case, the call above to find the next
1115 * volume will fail because in attempting to reserve the Volume
1116 * the code will realize that we already have a tape mounted,
1117 * and it will fail. This *should* only happen if there are
1118 * writers, thus the following test. In that case, we simply
1119 * bail out, and continue waiting, rather than plunging on
1120 * and hoping that the operator can resolve the problem.
1122 if (dcr->dev->num_writers != 0) {
1123 if (dcr->VolumeName[0]) {
1131 ok = reserve_device_for_read(dcr);
1133 rctx.jcr->read_dcr = dcr;
1134 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1135 dcr->dev->reserved_device,
1136 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1142 if (rctx.notify_dir) {
1144 BSOCK *dir = rctx.jcr->dir_bsock;
1145 pm_strcpy(dev_name, rctx.device->hdr.name);
1146 bash_spaces(dev_name);
1147 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1148 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1155 rctx.have_volume = false;
1157 Dmsg0(dbglvl, "Not OK.\n");
1162 * We "reserve" the drive by setting the ST_READ bit. No one else
1163 * should touch the drive until that is cleared.
1164 * This allows the DIR to "reserve" the device before actually
1167 static bool reserve_device_for_read(DCR *dcr)
1169 DEVICE *dev = dcr->dev;
1170 JCR *jcr = dcr->jcr;
1177 if (is_device_unmounted(dev)) {
1178 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
1179 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1180 jcr->JobId, dev->print_name());
1181 queue_reserve_message(jcr);
1185 if (dev->is_busy()) {
1186 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1188 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1189 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1190 jcr->JobId, dev->print_name());
1191 queue_reserve_message(jcr);
1195 dev->clear_append();
1198 dev->reserved_device++;
1199 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev);
1200 dcr->reserved_device = true;
1209 * We reserve the device for appending by incrementing the
1210 * reserved_device. We do virtually all the same work that
1211 * is done in acquire_device_for_append(), but we do
1212 * not attempt to mount the device. This routine allows
1213 * the DIR to reserve multiple devices before *really*
1214 * starting the job. It also permits the SD to refuse
1215 * certain devices (not up, ...).
1217 * Note, in reserving a device, if the device is for the
1218 * same pool and the same pool type, then it is acceptable.
1219 * The Media Type has already been checked. If we are
1220 * the first tor reserve the device, we put the pool
1221 * name and pool type in the device record.
1223 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1225 JCR *jcr = dcr->jcr;
1226 DEVICE *dev = dcr->dev;
1233 /* If device is being read, we cannot write it */
1234 if (dev->can_read()) {
1235 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1236 jcr->JobId, dev->print_name());
1237 Dmsg1(dbglvl, "%s", jcr->errmsg);
1238 queue_reserve_message(jcr);
1242 /* If device is unmounted, we are out of luck */
1243 if (is_device_unmounted(dev)) {
1244 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1245 jcr->JobId, dev->print_name());
1246 Dmsg1(dbglvl, "%s", jcr->errmsg);
1247 queue_reserve_message(jcr);
1251 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
1253 /* Now do detailed tests ... */
1254 if (can_reserve_drive(dcr, rctx) != 1) {
1255 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
1259 dev->reserved_device++;
1260 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device,
1261 dev->print_name(), dev);
1262 dcr->reserved_device = true;
1270 static int is_pool_ok(DCR *dcr)
1272 DEVICE *dev = dcr->dev;
1273 JCR *jcr = dcr->jcr;
1275 /* Now check if we want the same Pool and pool type */
1276 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1277 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1278 /* OK, compatible device */
1279 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1282 /* Drive Pool not suitable for us */
1283 Mmsg(jcr->errmsg, _(
1284 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1285 jcr->JobId, dcr->pool_name, dev->pool_name,
1286 dev->reserved_device, dev->print_name());
1287 queue_reserve_message(jcr);
1288 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1289 dev->pool_name, dcr->pool_name);
1294 static bool is_max_jobs_ok(DCR *dcr)
1296 DEVICE *dev = dcr->dev;
1297 JCR *jcr = dcr->jcr;
1299 Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n",
1300 dcr->VolCatInfo.VolCatMaxJobs,
1301 dcr->VolCatInfo.VolCatJobs, dev->reserved_device,
1303 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1304 (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) {
1305 /* Max Job Vols depassed or already reserved */
1306 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1307 (uint32_t)jcr->JobId, dev->print_name());
1308 queue_reserve_message(jcr);
1309 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1310 return false; /* wait */
1316 * Returns: 1 if drive can be reserved
1317 * 0 if we should wait
1318 * -1 on error or impossibility
1320 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1322 DEVICE *dev = dcr->dev;
1323 JCR *jcr = dcr->jcr;
1325 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1326 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1327 rctx.autochanger_only, rctx.any_drive);
1329 /* setting any_drive overrides PreferMountedVols flag */
1330 if (!rctx.any_drive) {
1332 * When PreferMountedVols is set, we keep track of the
1333 * drive in use that has the least number of writers, then if
1334 * no unmounted drive is found, we try that drive. This
1335 * helps spread the load to the least used drives.
1337 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1338 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
1339 dev->print_name(), rctx.low_use_drive->print_name());
1342 /* If he wants a free drive, but this one is busy, no go */
1343 if (!rctx.PreferMountedVols && dev->is_busy()) {
1344 /* Save least used drive */
1345 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1346 rctx.num_writers = dev->num_writers + dev->reserved_device;
1347 rctx.low_use_drive = dev;
1348 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
1349 dev->print_name(), rctx.num_writers);
1351 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->reserved_device);
1353 Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
1354 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1355 jcr->JobId, dev->print_name());
1356 queue_reserve_message(jcr);
1360 /* Check for prefer mounted volumes */
1361 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1362 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1363 jcr->JobId, dev->print_name());
1364 queue_reserve_message(jcr);
1365 Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
1366 return 0; /* No volume mounted */
1369 /* Check for exact Volume name match */
1370 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1373 if (rctx.exact_match && rctx.have_volume) {
1375 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1376 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1377 rctx.autochanger_only, rctx.any_drive);
1378 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1379 rctx.have_volume, dev->VolHdr.VolumeName,
1380 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1381 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1382 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1384 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1385 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1387 queue_reserve_message(jcr);
1388 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1389 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1392 if (is_volume_in_use(dcr)) {
1393 return 0; /* fail if volume on another drive */
1398 /* Check for unused autochanger drive */
1399 if (rctx.autochanger_only && !dev->is_busy() &&
1400 dev->VolHdr.VolumeName[0] == 0) {
1401 /* Device is available but not yet reserved, reserve it for us */
1402 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1403 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1404 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1405 return 1; /* reserve drive */
1409 * Handle the case that there are no writers
1411 if (dev->num_writers == 0) {
1412 /* Now check if there are any reservations on the drive */
1413 if (dev->reserved_device) {
1414 if (!is_max_jobs_ok(dcr)) {
1417 return is_pool_ok(dcr);
1418 } else if (dev->can_append()) {
1419 if (is_pool_ok(dcr)) {
1422 /* Changing pool, unload old tape if any in drive */
1423 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1424 unload_autochanger(dcr, 0);
1427 /* Device is available but not yet reserved, reserve it for us */
1428 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1429 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1430 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1431 return 1; /* reserve drive */
1435 * Check if the device is in append mode with writers (i.e.
1436 * available if pool is the same).
1438 if (dev->can_append() || dev->num_writers > 0) {
1439 if (!is_max_jobs_ok(dcr)) {
1442 return is_pool_ok(dcr);
1444 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1445 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1446 jcr->JobId, dev->print_name());
1447 queue_reserve_message(jcr);
1448 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1449 return -1; /* error, should not get here */
1451 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1452 jcr->JobId, dev->print_name());
1453 queue_reserve_message(jcr);
1454 Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1462 * Queue a reservation error or failure message for this jcr
1464 static void queue_reserve_message(JCR *jcr)
1472 msgs = jcr->reserve_msgs;
1477 * Look for duplicate message. If found, do
1480 for (i=msgs->size()-1; i >= 0; i--) {
1481 msg = (char *)msgs->get(i);
1485 /* Comparison based on 4 digit message number */
1486 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1490 /* Message unique, so insert it */
1491 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1498 * Send any reservation messages queued for this jcr
1500 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1507 msgs = jcr->reserve_msgs;
1508 if (!msgs || msgs->size() == 0) {
1511 for (i=msgs->size()-1; i >= 0; i--) {
1512 msg = (char *)msgs->get(i);
1514 sendit(" ", 3, arg);
1515 sendit(msg, strlen(msg), arg);
1526 * Pop and release any reservations messages
1528 static void pop_reserve_messages(JCR *jcr)
1534 msgs = jcr->reserve_msgs;
1538 while ((msg = (char *)msgs->pop())) {
1546 * Also called from acquire.c
1548 void release_reserve_messages(JCR *jcr)
1550 pop_reserve_messages(jcr);
1552 if (!jcr->reserve_msgs) {
1555 delete jcr->reserve_msgs;
1556 jcr->reserve_msgs = NULL;