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", vol->vol_name, vol->vol_name);
334 unload_autochanger(dcr, -1); /* unload the volume */
336 debug_list_volumes("reserve_vol free");
340 /* Create a new Volume entry */
341 nvol = new_vol_item(dcr, VolumeName);
344 * Now try to insert the new Volume
346 vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
348 Dmsg2(dbglvl, "Found vol=%s dev-same=%d\n", vol->vol_name, dev==vol->dev);
350 * At this point, a Volume with this name already is in the list,
351 * so we simply release our new Volume entry. Note, this should
352 * only happen if we are moving the volume from one drive to another.
354 Dmsg2(dbglvl, "reserve_vol free-tmp vol=%s at %p\n",
355 vol->vol_name, vol->vol_name);
357 * Clear dev pointer so that free_vol_item() doesn't
358 * take away our volume.
360 nvol->dev = NULL; /* don't zap dev entry */
363 /* Check if we are trying to use the Volume on a different drive */
364 if (dev != vol->dev) {
365 /* Caller wants to switch Volume to another device */
366 if (!vol->dev->is_busy()) {
367 /* OK to move it -- I'm not sure this will work */
368 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n", VolumeName,
369 vol->dev->print_name(), dev->print_name());
370 vol->dev->vol = NULL; /* take vol from old drive */
371 vol->dev->VolHdr.VolumeName[0] = 0;
372 vol->dev = dev; /* point vol at new drive */
373 dev->vol = vol; /* point dev at vol */
374 dev->VolHdr.VolumeName[0] = 0;
376 Dmsg3(dbglvl, "Volume busy could not swap vol=%s from dev=%s to %s\n",
377 VolumeName, vol->dev->print_name(), dev->print_name());
378 vol = NULL; /* device busy */
387 vol->released = false;
389 debug_list_volumes("end new volume");
395 * Switch from current device to given device
397 void switch_device(DCR *dcr, DEVICE *dev)
399 // lock_reservations();
403 memcpy(&save_dcr, dcr, sizeof(save_dcr));
404 clean_device(dcr); /* clean up the dcr */
406 dcr->dev = dev; /* get new device pointer */
407 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
408 dcr->dev->print_name());
410 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
411 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
412 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
413 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
414 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
415 bstrncpy(dcr->dev_name, save_dcr.dev_name, sizeof(dcr->dev_name));
417 dev->reserved_device++;
418 dcr->reserved_device = true;
424 * Search for a Volume name in the Volume list.
426 * Returns: VOLRES entry on success
427 * NULL if the Volume is not in the list
429 VOLRES *find_volume(DCR *dcr)
432 /* Do not lock reservations here */
434 vol.vol_name = bstrdup(dcr->VolumeName);
435 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
437 Dmsg2(dbglvl, "find_vol=%s found=%d\n", dcr->VolumeName, fvol!=NULL);
438 debug_list_volumes("find_volume");
444 * Remove any reservation from a drive and tell the system
445 * that the volume is unused at least by us.
447 void unreserve_device(DCR *dcr)
449 DEVICE *dev = dcr->dev;
450 if (dcr->reserved_device) {
451 dcr->reserved_device = false;
452 dev->reserved_device--;
453 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name());
454 dcr->reserved_device = false;
455 /* If we set read mode in reserving, remove it */
456 if (dev->can_read()) {
459 if (dev->num_writers < 0) {
460 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
461 dev->num_writers = 0;
469 * Free a Volume from the Volume list if it is no longer used
471 * Returns: true if the Volume found and removed from the list
472 * false if the Volume is not in the list or is in use
474 bool volume_unused(DCR *dcr)
476 DEVICE *dev = dcr->dev;
478 if (dev->vol == NULL) {
479 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
480 debug_list_volumes("null vol cannot unreserve_volume");
484 if (dev->is_busy()) {
485 Dmsg1(dbglvl, "vol_unused: busy on %s\n", dev->print_name());
486 debug_list_volumes("dev busy cannot unreserve_volume");
491 * If this is a tape, we do not free the volume, rather we wait
492 * until the autoloader unloads it, or until another tape is
493 * explicitly read in this drive. This allows the SD to remember
494 * where the tapes are or last were.
496 dev->vol->released = true;
497 if (dev->is_tape() || dev->is_autochanger()) {
500 return free_volume(dev);
505 * Unconditionally release the volume
507 bool free_volume(DEVICE *dev)
511 if (dev->vol == NULL) {
512 Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name());
518 vol_list->remove(vol);
519 Dmsg2(dbglvl, "free_volume %s dev=%s\n", vol->vol_name, dev->print_name());
521 debug_list_volumes("free_volume");
527 /* Create the Volume list */
528 void create_volume_list()
531 if (vol_list == NULL) {
532 vol_list = New(dlist(vol, &vol->link));
536 /* Release all Volumes from the list */
537 void free_volume_list()
544 foreach_dlist(vol, vol_list) {
546 Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name());
548 Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name);
551 vol->vol_name = NULL;
558 bool is_volume_in_use(DCR *dcr)
560 VOLRES *vol = find_volume(dcr);
562 Dmsg1(dbglvl, "Vol=%s not in use.\n", dcr->VolumeName);
563 return false; /* vol not in list */
565 ASSERT(vol->dev != NULL);
567 if (dcr->dev == vol->dev) { /* same device OK */
568 Dmsg1(dbglvl, "Vol=%s on same dev.\n", dcr->VolumeName);
571 Dmsg3(dbglvl, "Vol=%s on %s we have %s\n", dcr->VolumeName,
572 vol->dev->print_name(), dcr->dev->print_name());
574 if (!vol->dev->is_busy()) {
575 Dmsg2(dbglvl, "Vol=%s dev=%s not busy.\n", dcr->VolumeName, vol->dev->print_name());
578 Dmsg2(dbglvl, "Vol=%s dev=%s busy.\n", dcr->VolumeName, vol->dev->print_name());
580 Dmsg2(dbglvl, "Vol=%s in use by %s.\n", dcr->VolumeName, vol->dev->print_name());
586 * We get the following type of information:
588 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
592 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
596 static bool use_storage_cmd(JCR *jcr)
598 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
599 BSOCK *dir = jcr->dir_bsock;
607 memset(&rctx, 0, sizeof(RCTX));
610 * If there are multiple devices, the director sends us
611 * use_device for each device that it wants to use.
613 dirstore = New(alist(10, not_owned_by_alist));
614 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
616 Dmsg1(dbglvl, "<dird: %s", dir->msg);
617 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
618 media_type.c_str(), pool_name.c_str(),
619 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
624 jcr->write_store = dirstore;
626 jcr->read_store = dirstore;
628 rctx.append = append;
629 unbash_spaces(store_name);
630 unbash_spaces(media_type);
631 unbash_spaces(pool_name);
632 unbash_spaces(pool_type);
633 store = new DIRSTORE;
634 dirstore->append(store);
635 memset(store, 0, sizeof(DIRSTORE));
636 store->device = New(alist(10));
637 bstrncpy(store->name, store_name, sizeof(store->name));
638 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
639 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
640 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
641 store->append = append;
643 /* Now get all devices */
644 while (dir->recv() >= 0) {
645 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
646 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
650 unbash_spaces(dev_name);
651 store->device->append(bstrdup(dev_name.c_str()));
653 } while (ok && dir->recv() >= 0);
655 /* Developer debug code */
657 if (debug_level >= dbglvl) {
658 foreach_alist(store, dirstore) {
659 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
660 store->name, store->media_type, store->pool_name,
661 store->pool_type, store->append);
662 foreach_alist(device_name, store->device) {
663 Dmsg1(dbglvl, " Device=%s\n", device_name);
668 init_jcr_device_wait_timers(jcr);
669 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
671 BSOCK *dir = jcr->dir_bsock;
672 dir->fsend(_("3939 Could not get dcr\n"));
673 Dmsg1(dbglvl, ">dird: %s", dir->msg);
677 * At this point, we have a list of all the Director's Storage
678 * resources indicated for this Job, which include Pool, PoolType,
679 * storage name, and Media type.
680 * Then for each of the Storage resources, we have a list of
681 * device names that were given.
683 * Wiffle through them and find one that can do the backup.
686 int wait_for_device_retries = 0;
689 rctx.notify_dir = true;
692 for ( ; !fail && !job_canceled(jcr); ) {
693 pop_reserve_messages(jcr);
694 rctx.suitable_device = false;
695 rctx.have_volume = false;
696 rctx.VolumeName[0] = 0;
697 rctx.any_drive = false;
698 if (!jcr->PreferMountedVols) {
700 * Here we try to find a drive that is not used.
701 * This will maximize the use of available drives.
704 rctx.num_writers = 20000000; /* start with impossible number */
705 rctx.low_use_drive = NULL;
706 rctx.PreferMountedVols = false;
707 rctx.exact_match = false;
708 rctx.autochanger_only = true;
709 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
710 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
711 rctx.autochanger_only, rctx.any_drive);
712 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
715 /* Look through all drives possibly for low_use drive */
716 if (rctx.low_use_drive) {
717 rctx.try_low_use_drive = true;
718 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
721 rctx.try_low_use_drive = false;
723 rctx.autochanger_only = false;
724 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
725 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
726 rctx.autochanger_only, rctx.any_drive);
727 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
732 * Now we look for a drive that may or may not be in
735 /* Look for an exact Volume match all drives */
736 rctx.PreferMountedVols = true;
737 rctx.exact_match = true;
738 rctx.autochanger_only = false;
739 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
740 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
741 rctx.autochanger_only, rctx.any_drive);
742 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
745 /* Look for any mounted drive */
746 rctx.exact_match = false;
747 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
748 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
749 rctx.autochanger_only, rctx.any_drive);
750 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
754 rctx.any_drive = true;
755 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
756 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
757 rctx.autochanger_only, rctx.any_drive);
758 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
761 /* Keep reservations locked *except* during wait_for_device() */
762 unlock_reservations();
764 * The idea of looping on repeat a few times it to ensure
765 * that if there is some subtle timing problem between two
766 * jobs, we will simply try again, and most likely succeed.
767 * This can happen if one job reserves a drive or finishes using
768 * a drive at the same time a second job wants it.
770 if (repeat++ > 1) { /* try algorithm 3 times */
771 bmicrosleep(30, 0); /* wait a bit */
772 Dmsg0(dbglvl, "repeat reserve algorithm\n");
773 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
774 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
778 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
780 unlock_reservations();
783 * If we get here, there are no suitable devices available, which
784 * means nothing configured. If a device is suitable but busy
785 * with another Volume, we will not come here.
787 unbash_spaces(dir->msg);
788 pm_strcpy(jcr->errmsg, dir->msg);
789 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
790 Jmsg(jcr, M_FATAL, 0, _("\n"
791 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
792 dev_name.c_str(), media_type.c_str());
793 dir->fsend(NO_device, dev_name.c_str());
795 Dmsg1(dbglvl, ">dird: %s", dir->msg);
798 unbash_spaces(dir->msg);
799 pm_strcpy(jcr->errmsg, dir->msg);
800 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
801 dir->fsend(BAD_use, jcr->errmsg);
802 Dmsg1(dbglvl, ">dird: %s", dir->msg);
805 release_reserve_messages(jcr);
811 * Walk through the autochanger resources and check if
812 * the volume is in one of them.
814 * Returns: true if volume is in device
817 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
819 AUTOCHANGER *changer = vol->dev->device->changer_res;
821 /* Find resource, and make sure we were able to open it */
822 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
823 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
826 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
831 * Search for a device suitable for this job.
833 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
842 dirstore = jcr->write_store;
844 dirstore = jcr->read_store;
846 Dmsg4(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
847 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
848 rctx.autochanger_only);
851 * If the appropriate conditions of this if are met, namely that
852 * we are appending and the user wants mounted drive (or we
853 * force try a mounted drive because they are all busy), we
854 * start by looking at all the Volumes in the volume list.
856 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
857 dlist *temp_vol_list, *save_vol_list;
860 Dmsg0(dbglvl, "lock volumes\n");
863 * Create a temporary copy of the volume list. We do this,
864 * to avoid having the volume list locked during the
865 * call to reserve_device(), which would cause a deadlock.
866 * Note, we may want to add an update counter on the vol_list
867 * so that if it is modified while we are traversing the copy
868 * we can take note and act accordingly (probably redo the
869 * search at least a few times).
871 Dmsg0(dbglvl, "duplicate vol list\n");
872 temp_vol_list = New(dlist(vol, &vol->link));
873 foreach_dlist(vol, vol_list) {
875 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
876 memset(tvol, 0, sizeof(VOLRES));
877 tvol->vol_name = bstrdup(vol->vol_name);
878 tvol->dev = vol->dev;
879 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
881 tvol->dev = NULL; /* don't zap dev entry */
883 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
884 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
887 Dmsg0(dbglvl, "unlock volumes\n");
890 /* Look through reserved volumes for one we can use */
891 Dmsg0(dbglvl, "look for vol in vol list\n");
892 foreach_dlist(vol, temp_vol_list) {
894 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
897 /* Check with Director if this Volume is OK */
898 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
899 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
903 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
904 foreach_alist(store, dirstore) {
907 foreach_alist(device_name, store->device) {
908 /* Found a device, try to use it */
909 rctx.device_name = device_name;
910 rctx.device = vol->dev->device;
912 if (vol->dev->is_autochanger()) {
913 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
914 if (!is_vol_in_autochanger(rctx, vol)) {
917 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
918 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
919 vol->dev->device->hdr.name, device_name);
923 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
924 rctx.have_volume = true;
925 /* Try reserving this device and volume */
926 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
927 stat = reserve_device(rctx);
928 if (stat == 1) { /* found available device */
929 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
932 } else if (stat == 0) { /* device busy */
933 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
935 /* otherwise error */
936 Dmsg0(dbglvl, "No suitable device found.\n");
938 rctx.have_volume = false;
947 } /* end for loop over reserved volumes */
949 Dmsg0(dbglvl, "lock volumes\n");
951 save_vol_list = vol_list;
952 vol_list = temp_vol_list;
953 free_volume_list(); /* release temp_vol_list */
954 vol_list = save_vol_list;
955 Dmsg0(dbglvl, "deleted temp vol list\n");
956 Dmsg0(dbglvl, "lock volumes\n");
960 Dmsg1(dbglvl, "got vol %s from in-use vols list\n", rctx.VolumeName);
965 * No reserved volume we can use, so now search for an available device.
967 * For each storage device that the user specified, we
968 * search and see if there is a resource for that device.
970 foreach_alist(store, dirstore) {
972 foreach_alist(device_name, store->device) {
974 rctx.device_name = device_name;
975 stat = search_res_for_device(rctx);
976 if (stat == 1) { /* found available device */
977 Dmsg1(dbglvl, "available device found=%s\n", device_name);
980 } else if (stat == 0) { /* device busy */
981 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
983 /* otherwise error */
984 Dmsg0(dbglvl, "No suitable device found.\n");
995 * Search for a particular storage device with particular storage
996 * characteristics (MediaType).
998 int search_res_for_device(RCTX &rctx)
1000 AUTOCHANGER *changer;
1003 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
1004 /* Look through Autochangers first */
1005 foreach_res(changer, R_AUTOCHANGER) {
1006 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
1007 /* Find resource, and make sure we were able to open it */
1008 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1009 /* Try each device in this AutoChanger */
1010 foreach_alist(rctx.device, changer->device) {
1011 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
1012 stat = reserve_device(rctx);
1013 if (stat != 1) { /* try another device */
1017 if (rctx.store->append == SD_APPEND) {
1018 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1019 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1021 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1022 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1029 /* Now if requested look through regular devices */
1030 if (!rctx.autochanger_only) {
1031 foreach_res(rctx.device, R_DEVICE) {
1032 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
1033 /* Find resource, and make sure we were able to open it */
1034 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1035 stat = reserve_device(rctx);
1036 if (stat != 1) { /* try another device */
1040 if (rctx.store->append == SD_APPEND) {
1041 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1042 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1044 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1045 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1051 return -1; /* nothing found */
1055 * Try to reserve a specific device.
1057 * Returns: 1 -- OK, have DCR
1061 static int reserve_device(RCTX &rctx)
1065 const int name_len = MAX_NAME_LENGTH;
1067 /* Make sure MediaType is OK */
1068 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
1069 rctx.device->media_type, rctx.store->media_type);
1070 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1074 /* Make sure device exists -- i.e. we can stat() it */
1075 if (!rctx.device->dev) {
1076 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1078 if (!rctx.device->dev) {
1079 if (rctx.device->changer_res) {
1080 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1081 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1082 rctx.device->hdr.name, rctx.device_name);
1084 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1085 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1088 return -1; /* no use waiting */
1091 rctx.suitable_device = true;
1092 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1093 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1095 BSOCK *dir = rctx.jcr->dir_bsock;
1096 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1097 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1100 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1101 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1102 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1103 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1104 if (rctx.store->append == SD_APPEND) {
1105 Dmsg2(dbglvl, "have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
1106 ok = reserve_device_for_append(dcr, rctx);
1111 rctx.jcr->dcr = dcr;
1112 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1113 dcr->dev->reserved_device,
1114 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1115 if (!rctx.have_volume) {
1116 dcr->any_volume = true;
1117 if (dir_find_next_appendable_volume(dcr)) {
1118 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1119 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
1120 rctx.have_volume = true;
1122 Dmsg0(dbglvl, "No next volume found\n");
1123 rctx.have_volume = false;
1124 rctx.VolumeName[0] = 0;
1126 * If there is at least one volume that is valid and in use,
1127 * but we get here, check if we are running with prefers
1128 * non-mounted drives. In that case, we have selected a
1129 * non-used drive and our one and only volume is mounted
1130 * elsewhere, so we bail out and retry using that drive.
1132 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1133 rctx.PreferMountedVols = true;
1134 if (dcr->VolumeName[0]) {
1140 * Note. Under some circumstances, the Director can hand us
1141 * a Volume name that is no the same as the one on the current
1142 * drive, and in that case, the call above to find the next
1143 * volume will fail because in attempting to reserve the Volume
1144 * the code will realize that we already have a tape mounted,
1145 * and it will fail. This *should* only happen if there are
1146 * writers, thus the following test. In that case, we simply
1147 * bail out, and continue waiting, rather than plunging on
1148 * and hoping that the operator can resolve the problem.
1150 if (dcr->dev->num_writers != 0) {
1151 if (dcr->VolumeName[0]) {
1159 ok = reserve_device_for_read(dcr);
1161 rctx.jcr->read_dcr = dcr;
1162 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1163 dcr->dev->reserved_device,
1164 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1170 if (rctx.notify_dir) {
1172 BSOCK *dir = rctx.jcr->dir_bsock;
1173 pm_strcpy(dev_name, rctx.device->hdr.name);
1174 bash_spaces(dev_name);
1175 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1176 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1183 rctx.have_volume = false;
1185 Dmsg0(dbglvl, "Not OK.\n");
1190 * We "reserve" the drive by setting the ST_READ bit. No one else
1191 * should touch the drive until that is cleared.
1192 * This allows the DIR to "reserve" the device before actually
1195 static bool reserve_device_for_read(DCR *dcr)
1197 DEVICE *dev = dcr->dev;
1198 JCR *jcr = dcr->jcr;
1205 if (is_device_unmounted(dev)) {
1206 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
1207 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1208 jcr->JobId, dev->print_name());
1209 queue_reserve_message(jcr);
1213 if (dev->is_busy()) {
1214 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1216 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1217 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1218 jcr->JobId, dev->print_name());
1219 queue_reserve_message(jcr);
1223 dev->clear_append();
1226 dev->reserved_device++;
1227 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev);
1228 dcr->reserved_device = true;
1237 * We reserve the device for appending by incrementing the
1238 * reserved_device. We do virtually all the same work that
1239 * is done in acquire_device_for_append(), but we do
1240 * not attempt to mount the device. This routine allows
1241 * the DIR to reserve multiple devices before *really*
1242 * starting the job. It also permits the SD to refuse
1243 * certain devices (not up, ...).
1245 * Note, in reserving a device, if the device is for the
1246 * same pool and the same pool type, then it is acceptable.
1247 * The Media Type has already been checked. If we are
1248 * the first tor reserve the device, we put the pool
1249 * name and pool type in the device record.
1251 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1253 JCR *jcr = dcr->jcr;
1254 DEVICE *dev = dcr->dev;
1261 /* If device is being read, we cannot write it */
1262 if (dev->can_read()) {
1263 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1264 jcr->JobId, dev->print_name());
1265 Dmsg1(dbglvl, "%s", jcr->errmsg);
1266 queue_reserve_message(jcr);
1270 /* If device is unmounted, we are out of luck */
1271 if (is_device_unmounted(dev)) {
1272 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1273 jcr->JobId, dev->print_name());
1274 Dmsg1(dbglvl, "%s", jcr->errmsg);
1275 queue_reserve_message(jcr);
1279 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
1281 /* Now do detailed tests ... */
1282 if (can_reserve_drive(dcr, rctx) != 1) {
1283 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
1287 dev->reserved_device++;
1288 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device,
1289 dev->print_name(), dev);
1290 dcr->reserved_device = true;
1298 static int is_pool_ok(DCR *dcr)
1300 DEVICE *dev = dcr->dev;
1301 JCR *jcr = dcr->jcr;
1303 /* Now check if we want the same Pool and pool type */
1304 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1305 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1306 /* OK, compatible device */
1307 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1310 /* Drive Pool not suitable for us */
1311 Mmsg(jcr->errmsg, _(
1312 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1313 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1314 dev->reserved_device, dev->print_name());
1315 queue_reserve_message(jcr);
1316 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1317 dev->pool_name, dcr->pool_name);
1322 static bool is_max_jobs_ok(DCR *dcr)
1324 DEVICE *dev = dcr->dev;
1325 JCR *jcr = dcr->jcr;
1327 Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n",
1328 dcr->VolCatInfo.VolCatMaxJobs,
1329 dcr->VolCatInfo.VolCatJobs, dev->reserved_device,
1331 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1332 (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) {
1333 /* Max Job Vols depassed or already reserved */
1334 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1335 (uint32_t)jcr->JobId, dev->print_name());
1336 queue_reserve_message(jcr);
1337 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1338 return false; /* wait */
1344 * Returns: 1 if drive can be reserved
1345 * 0 if we should wait
1346 * -1 on error or impossibility
1348 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1350 DEVICE *dev = dcr->dev;
1351 JCR *jcr = dcr->jcr;
1353 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1354 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1355 rctx.autochanger_only, rctx.any_drive);
1357 /* Check for max jobs on this Volume */
1358 if (!is_max_jobs_ok(dcr)) {
1362 /* setting any_drive overrides PreferMountedVols flag */
1363 if (!rctx.any_drive) {
1365 * When PreferMountedVols is set, we keep track of the
1366 * drive in use that has the least number of writers, then if
1367 * no unmounted drive is found, we try that drive. This
1368 * helps spread the load to the least used drives.
1370 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1371 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
1372 dev->print_name(), rctx.low_use_drive->print_name());
1375 /* If he wants a free drive, but this one is busy, no go */
1376 if (!rctx.PreferMountedVols && dev->is_busy()) {
1377 /* Save least used drive */
1378 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1379 rctx.num_writers = dev->num_writers + dev->reserved_device;
1380 rctx.low_use_drive = dev;
1381 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
1382 dev->print_name(), rctx.num_writers);
1384 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->reserved_device);
1386 Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
1387 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1388 jcr->JobId, dev->print_name());
1389 queue_reserve_message(jcr);
1393 /* Check for prefer mounted volumes */
1394 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1395 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1396 jcr->JobId, dev->print_name());
1397 queue_reserve_message(jcr);
1398 Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
1399 return 0; /* No volume mounted */
1402 /* Check for exact Volume name match */
1403 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1406 if (rctx.exact_match && rctx.have_volume) {
1408 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1409 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1410 rctx.autochanger_only, rctx.any_drive);
1411 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1412 rctx.have_volume, dev->VolHdr.VolumeName,
1413 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1414 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1415 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1417 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1418 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1420 queue_reserve_message(jcr);
1421 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1422 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1425 if (is_volume_in_use(dcr)) {
1426 return 0; /* fail if volume on another drive */
1431 /* Check for unused autochanger drive */
1432 if (rctx.autochanger_only && !dev->is_busy() &&
1433 dev->VolHdr.VolumeName[0] == 0) {
1434 /* Device is available but not yet reserved, reserve it for us */
1435 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1436 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1437 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1438 return 1; /* reserve drive */
1442 * Handle the case that there are no writers
1444 if (dev->num_writers == 0) {
1445 /* Now check if there are any reservations on the drive */
1446 if (dev->reserved_device) {
1447 return is_pool_ok(dcr);
1448 } else if (dev->can_append()) {
1449 if (is_pool_ok(dcr)) {
1452 /* Changing pool, unload old tape if any in drive */
1453 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1454 unload_autochanger(dcr, 0);
1457 /* Device is available but not yet reserved, reserve it for us */
1458 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1459 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1460 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1461 return 1; /* reserve drive */
1465 * Check if the device is in append mode with writers (i.e.
1466 * available if pool is the same).
1468 if (dev->can_append() || dev->num_writers > 0) {
1469 return is_pool_ok(dcr);
1471 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1472 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1473 jcr->JobId, dev->print_name());
1474 queue_reserve_message(jcr);
1475 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1476 return -1; /* error, should not get here */
1478 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1479 jcr->JobId, dev->print_name());
1480 queue_reserve_message(jcr);
1481 Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1489 * Queue a reservation error or failure message for this jcr
1491 static void queue_reserve_message(JCR *jcr)
1499 msgs = jcr->reserve_msgs;
1504 * Look for duplicate message. If found, do
1507 for (i=msgs->size()-1; i >= 0; i--) {
1508 msg = (char *)msgs->get(i);
1512 /* Comparison based on 4 digit message number */
1513 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1517 /* Message unique, so insert it */
1518 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1525 * Send any reservation messages queued for this jcr
1527 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1534 msgs = jcr->reserve_msgs;
1535 if (!msgs || msgs->size() == 0) {
1538 for (i=msgs->size()-1; i >= 0; i--) {
1539 msg = (char *)msgs->get(i);
1541 sendit(" ", 3, arg);
1542 sendit(msg, strlen(msg), arg);
1553 * Pop and release any reservations messages
1555 static void pop_reserve_messages(JCR *jcr)
1561 msgs = jcr->reserve_msgs;
1565 while ((msg = (char *)msgs->pop())) {
1573 * Also called from acquire.c
1575 void release_reserve_messages(JCR *jcr)
1577 pop_reserve_messages(jcr);
1579 if (!jcr->reserve_msgs) {
1582 delete jcr->reserve_msgs;
1583 jcr->reserve_msgs = NULL;