2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of John Walker.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
29 * Drive reservation functions for Storage Daemon
33 * Split from job.c and acquire.c June 2005
42 const int dbglvl = 50;
44 static dlist *vol_list = NULL;
45 static brwlock_t reservation_lock;
46 static brwlock_t vol_list_lock;
48 /* Forward referenced functions */
49 static int can_reserve_drive(DCR *dcr, RCTX &rctx);
50 static int reserve_device(RCTX &rctx);
51 static bool reserve_device_for_read(DCR *dcr);
52 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx);
53 static bool use_storage_cmd(JCR *jcr);
54 static void queue_reserve_message(JCR *jcr);
55 static void pop_reserve_messages(JCR *jcr);
56 //void switch_device(DCR *dcr, DEVICE *dev);
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 * This allows a given thread to recursively call lock_reservations.
88 * It must, of course, call unlock_... the same number of times.
90 void init_reservations_lock()
93 if ((errstat=rwl_init(&reservation_lock)) != 0) {
95 Emsg1(M_ABORT, 0, _("Unable to initialize reservation lock. ERR=%s\n"),
96 be.bstrerror(errstat));
99 if ((errstat=rwl_init(&vol_list_lock)) != 0) {
101 Emsg1(M_ABORT, 0, _("Unable to initialize volume list lock. ERR=%s\n"),
102 be.bstrerror(errstat));
106 void term_reservations_lock()
108 rwl_destroy(&reservation_lock);
109 rwl_destroy(&vol_list_lock);
112 int reservations_lock_count = 0;
114 /* This applies to a drive and to Volumes */
115 void _lock_reservations()
118 reservations_lock_count++;
119 if ((errstat=rwl_writelock(&reservation_lock)) != 0) {
121 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
122 errstat, be.bstrerror(errstat));
126 void _unlock_reservations()
129 reservations_lock_count--;
130 if ((errstat=rwl_writeunlock(&reservation_lock)) != 0) {
132 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
133 errstat, be.bstrerror(errstat));
137 int vol_list_lock_count = 0;
140 * This allows a given thread to recursively call to lock_volumes()
145 vol_list_lock_count++;
146 if ((errstat=rwl_writelock(&vol_list_lock)) != 0) {
148 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
149 errstat, be.bstrerror(errstat));
153 void _unlock_volumes()
156 vol_list_lock_count--;
157 if ((errstat=rwl_writeunlock(&vol_list_lock)) != 0) {
159 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
160 errstat, be.bstrerror(errstat));
166 * List Volumes -- this should be moved to status.c
173 static void debug_list_volumes(const char *imsg)
176 POOL_MEM msg(PM_MESSAGE);
179 foreach_dlist(vol, vol_list) {
181 Mmsg(msg, "List %s: %s in_use=%d on device %s\n", imsg,
182 vol->vol_name, vol->is_in_use(), vol->dev->print_name());
184 Mmsg(msg, "List %s: %s in_use=%d no dev\n", imsg, vol->vol_name,
187 Dmsg1(dbglvl, "%s", msg.c_str());
192 foreach_dlist(vol, vol_list) {
193 if (vol->dev == dev) {
194 Dmsg0(dbglvl, "Two Volumes on same device.\n");
206 * List Volumes -- this should be moved to status.c
208 void list_volumes(void sendit(const char *msg, int len, void *sarg), void *arg)
211 POOL_MEM msg(PM_MESSAGE);
215 foreach_dlist(vol, vol_list) {
216 DEVICE *dev = vol->dev;
218 len = Mmsg(msg, "%s on device %s\n", vol->vol_name, dev->print_name());
219 sendit(msg.c_str(), len, arg);
220 len = Mmsg(msg, " Reader=%d writers=%d devres=%d volinuse=%d\n",
221 dev->can_read()?1:0, dev->num_writers, dev->num_reserved(),
223 sendit(msg.c_str(), len, arg);
225 len = Mmsg(msg, "%s no device. volinuse= %d\n", vol->vol_name,
227 sendit(msg.c_str(), len, arg);
234 * Create a Volume item to put in the Volume list
235 * Ensure that the device points to it.
237 static VOLRES *new_vol_item(DCR *dcr, const char *VolumeName)
240 vol = (VOLRES *)malloc(sizeof(VOLRES));
241 memset(vol, 0, sizeof(VOLRES));
242 vol->vol_name = bstrdup(VolumeName);
244 Dmsg3(dbglvl, "new Vol=%s at %p dev=%s\n",
245 VolumeName, vol->vol_name, vol->dev->print_name());
249 static void free_vol_item(VOLRES *vol)
264 * Put a new Volume entry in the Volume list. This
265 * effectively reserves the volume so that it will
266 * not be mounted again.
268 * If the device has any current volume associated with it,
269 * and it is a different Volume, and the device is not busy,
270 * we release the old Volume item and insert the new one.
272 * It is assumed that the device is free and locked so that
273 * we can change the device structure.
275 * Some details of the Volume list handling:
277 * 1. The Volume list entry must be attached to the drive (rather than
278 * attached to a job as it currently is. I.e. the drive that "owns"
279 * the volume (in use, mounted)
280 * must point to the volume (still to be maintained in a list).
282 * 2. The Volume is entered in the list when a drive is reserved.
284 * 3. When a drive is in use, the device code must appropriately update the
285 * volume name as it changes (currently the list is static -- an entry is
286 * removed when the Volume is no longer reserved, in use or mounted).
287 * The new code must keep the same list entry as long as the drive
288 * has any volume associated with it but the volume name in the list
289 * must be updated when the drive has a different volume mounted.
291 * 4. A job that has reserved a volume, can un-reserve the volume, and if the
292 * volume is not mounted, and not reserved, and not in use, it will be
293 * removed from the list.
295 * 5. If a job wants to reserve a drive with a different Volume from the one on
296 * the drive, it can re-use the drive for the new Volume.
298 * 6. If a job wants a Volume that is in a different drive, it can either use the
299 * other drive or take the volume, only if the other drive is not in use or
302 * One nice aspect of this is that the reserve use count and the writer use count
303 * already exist and are correctly programmed and will need no changes -- use
304 * counts are always very tricky.
306 * The old code had a concept of "reserving" a Volume, but was changed
307 * to reserving and using a drive. A volume is must be attached to (owned by) a
308 * drive and can move from drive to drive or be unused given certain specific
309 * conditions of the drive. The key is that the drive must "own" the Volume.
310 * The old code had the job (dcr) owning the volume (more or less). The job was
311 * to change the insertion and removal of the volumes from the list to be based
312 * on the drive rather than the job.
314 * Return: VOLRES entry on success
315 * NULL volume busy on another drive
317 VOLRES *reserve_volume(DCR *dcr, const char *VolumeName)
320 DEVICE * volatile dev = dcr->dev;
324 Dmsg2(dbglvl, "enter reserve_volume=%s drive=%s\n", VolumeName,
325 dcr->dev->print_name());
327 * We lock the reservations system here to ensure
328 * when adding a new volume that no newly scheduled
329 * job can reserve it.
332 debug_list_volumes("begin reserve_volume");
334 * First, remove any old volume attached to this device as it
339 Dmsg4(dbglvl, "Vol attached=%s, newvol=%s volinuse=%d on %s\n",
340 vol->vol_name, VolumeName, vol->is_in_use(), dev->print_name());
342 * Make sure we don't remove the current volume we are inserting
343 * because it was probably inserted by another job, or it
344 * is not being used and is marked as not reserved.
346 if (strcmp(vol->vol_name, VolumeName) == 0) {
347 Dmsg2(dbglvl, "=== set reserved vol=%s dev=%s\n", VolumeName,
348 vol->dev->print_name());
349 vol->set_in_use(); /* retake vol if released previously */
350 dcr->reserved_volume = true; /* reserved volume */
351 goto get_out; /* Volume already on this device */
353 /* Don't release a volume if it was reserved by someone other than us */
354 if (vol->is_in_use() && !dcr->reserved_volume) {
355 Dmsg1(dbglvl, "Cannot free vol=%s. It is reserved.\n", vol->vol_name);
356 vol = NULL; /* vol in use */
359 Dmsg2(dbglvl, "reserve_vol free vol=%s at %p\n", vol->vol_name, vol->vol_name);
361 dev->set_unload(); /* have to unload current volume */
362 debug_list_volumes("reserve_vol free");
366 /* Create a new Volume entry */
367 nvol = new_vol_item(dcr, VolumeName);
370 * Now try to insert the new Volume
372 vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
374 Dmsg2(dbglvl, "Found vol=%s dev-same=%d\n", vol->vol_name, dev==vol->dev);
376 * At this point, a Volume with this name already is in the list,
377 * so we simply release our new Volume entry. Note, this should
378 * only happen if we are moving the volume from one drive to another.
380 Dmsg2(dbglvl, "reserve_vol free-tmp vol=%s at %p\n",
381 vol->vol_name, vol->vol_name);
383 * Clear dev pointer so that free_vol_item() doesn't
384 * take away our volume.
386 nvol->dev = NULL; /* don't zap dev entry */
390 * Check if we are trying to use the Volume on a different drive
392 * vol->dev is where the Volume we want is
394 if (dev != vol->dev) {
395 /* Caller wants to switch Volume to another device */
396 if (!vol->dev->is_busy() && !vol->is_swapping()) {
397 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n",
398 VolumeName, vol->dev->print_name(), dev->print_name());
399 free_volume(dev); /* free any volume attached to our drive */
400 vol->dev->set_unload(); /* unload the other drive */
401 vol->set_swapping(); /* swap from other drive */
402 dev->swap_dev = vol->dev; /* remember to get this vol */
403 vol->dev->set_load(); /* then reload on our drive */
404 vol->dev->vol = NULL; /* remove volume from other drive */
405 vol->dev = dev; /* point the Volume at our drive */
406 dev->vol = vol; /* point our drive at the Volume */
408 Dmsg3(dbglvl, "==== Swap not possible Vol busy vol=%s from dev=%s to %s\n",
409 VolumeName, vol->dev->print_name(), dev->print_name());
410 vol = NULL; /* device busy */
417 dev->vol = vol; /* point to newly inserted volume */
422 Dmsg2(dbglvl, "=== set in_use. vol=%s dev=%s\n", vol->vol_name,
423 vol->dev->print_name());
425 dcr->reserved_volume = true;
427 debug_list_volumes("end new volume");
433 * Switch from current device to given device
437 void switch_device(DCR *dcr, DEVICE *dev)
442 memcpy(&save_dcr, dcr, sizeof(save_dcr));
443 clean_device(dcr); /* clean up the dcr */
445 dcr->dev = dev; /* get new device pointer */
446 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
447 dcr->dev->print_name());
449 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
450 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
451 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
452 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
453 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
454 bstrncpy(dcr->dev_name, dev->dev_name, sizeof(dcr->dev_name));
456 // dcr->set_reserved();
463 * Search for a Volume name in the Volume list.
465 * Returns: VOLRES entry on success
466 * NULL if the Volume is not in the list
468 VOLRES *find_volume(const char *VolumeName)
471 /* Do not lock reservations here */
473 vol.vol_name = bstrdup(VolumeName);
474 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
476 Dmsg2(dbglvl, "find_vol=%s found=%d\n", VolumeName, fvol!=NULL);
477 debug_list_volumes("find_volume");
482 void DCR::set_reserved()
485 Dmsg2(dbglvl, "Inc reserve=%d dev=%s\n", dev->num_reserved(), dev->print_name());
489 void DCR::clear_reserved()
494 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->num_reserved(), dev->print_name());
499 * Remove any reservation from a drive and tell the system
500 * that the volume is unused at least by us.
502 void DCR::unreserve_device()
507 reserved_volume = false;
508 /* If we set read mode in reserving, remove it */
509 if (dev->can_read()) {
512 if (dev->num_writers < 0) {
513 Jmsg1(jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
514 dev->num_writers = 0;
516 if (dev->num_reserved() == 0 && dev->num_writers == 0) {
524 * Free a Volume from the Volume list if it is no longer used
525 * Note, for tape drives we want to remember where the Volume
526 * was when last used, so rather than free the volume entry,
527 * we simply mark it "not reserved" so when the drive is really
528 * needed for another volume, we can reuse it.
530 * Returns: true if the Volume found and "removed" from the list
531 * false if the Volume is not in the list or is in use
533 bool volume_unused(DCR *dcr)
535 DEVICE *dev = dcr->dev;
538 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
539 debug_list_volumes("null vol cannot unreserve_volume");
542 if (dev->vol->is_swapping()) {
543 Dmsg1(dbglvl, "vol_unused: vol being swapped on %s\n", dev->print_name());
544 debug_list_volumes("swapping vol cannot unreserve_volume");
549 if (dev->is_busy()) {
550 Dmsg1(dbglvl, "vol_unused: busy on %s\n", dev->print_name());
551 debug_list_volumes("dev busy cannot unreserve_volume");
556 if (dev->num_writers > 0 || dev->num_reserved() > 0) {
562 * If this is a tape, we do not free the volume, rather we wait
563 * until the autoloader unloads it, or until another tape is
564 * explicitly read in this drive. This allows the SD to remember
565 * where the tapes are or last were.
567 Dmsg4(dbglvl, "=== set not reserved vol=%s num_writers=%d dev_reserved=%d dev=%s\n",
568 dev->vol->vol_name, dev->num_writers, dev->num_reserved(), dev->print_name());
569 dev->vol->clear_in_use();
570 if (dev->is_tape() || dev->is_autochanger()) {
574 * Note, this frees the volume reservation entry, but the
575 * file descriptor remains open with the OS.
577 return free_volume(dev);
582 * Unconditionally release the volume entry
584 bool free_volume(DEVICE *dev)
588 if (dev->vol == NULL) {
589 Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name());
594 /* Don't free a volume while it is being swapped */
595 if (!vol->is_swapping()) {
597 vol_list->remove(vol);
598 Dmsg2(dbglvl, "=== free_volume %s dev=%s\n", vol->vol_name, dev->print_name());
600 debug_list_volumes("free_volume");
607 /* Create the Volume list */
608 void create_volume_list()
611 if (vol_list == NULL) {
612 vol_list = New(dlist(vol, &vol->link));
616 /* Release all Volumes from the list */
617 void free_volume_list()
624 foreach_dlist(vol, vol_list) {
626 Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name());
628 Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name);
631 vol->vol_name = NULL;
638 bool DCR::can_i_use_volume()
644 vol = find_volume(VolumeName);
646 Dmsg1(dbglvl, "Vol=%s not in use.\n", VolumeName);
647 goto get_out; /* vol not in list */
649 ASSERT(vol->dev != NULL);
651 if (dev == vol->dev) { /* same device OK */
652 Dmsg1(dbglvl, "Vol=%s on same dev.\n", VolumeName);
655 Dmsg3(dbglvl, "Vol=%s on %s we have %s\n", VolumeName,
656 vol->dev->print_name(), dev->print_name());
658 /* ***FIXME*** check this ... */
659 if (!vol->dev->is_busy()) {
660 Dmsg2(dbglvl, "Vol=%s dev=%s not busy.\n", VolumeName, vol->dev->print_name());
663 Dmsg2(dbglvl, "Vol=%s dev=%s busy.\n", VolumeName, vol->dev->print_name());
665 Dmsg2(dbglvl, "Vol=%s in use by %s.\n", VolumeName, vol->dev->print_name());
676 * We get the following type of information:
678 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
682 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
686 static bool use_storage_cmd(JCR *jcr)
688 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
689 BSOCK *dir = jcr->dir_bsock;
697 memset(&rctx, 0, sizeof(RCTX));
700 * If there are multiple devices, the director sends us
701 * use_device for each device that it wants to use.
703 dirstore = New(alist(10, not_owned_by_alist));
704 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
706 Dmsg1(dbglvl, "<dird: %s", dir->msg);
707 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
708 media_type.c_str(), pool_name.c_str(),
709 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
714 jcr->write_store = dirstore;
716 jcr->read_store = dirstore;
718 rctx.append = append;
719 unbash_spaces(store_name);
720 unbash_spaces(media_type);
721 unbash_spaces(pool_name);
722 unbash_spaces(pool_type);
723 store = new DIRSTORE;
724 dirstore->append(store);
725 memset(store, 0, sizeof(DIRSTORE));
726 store->device = New(alist(10));
727 bstrncpy(store->name, store_name, sizeof(store->name));
728 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
729 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
730 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
731 store->append = append;
733 /* Now get all devices */
734 while (dir->recv() >= 0) {
735 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
736 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
740 unbash_spaces(dev_name);
741 store->device->append(bstrdup(dev_name.c_str()));
743 } while (ok && dir->recv() >= 0);
745 /* Developer debug code */
747 if (debug_level >= dbglvl) {
748 foreach_alist(store, dirstore) {
749 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
750 store->name, store->media_type, store->pool_name,
751 store->pool_type, store->append);
752 foreach_alist(device_name, store->device) {
753 Dmsg1(dbglvl, " Device=%s\n", device_name);
758 init_jcr_device_wait_timers(jcr);
759 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
761 BSOCK *dir = jcr->dir_bsock;
762 dir->fsend(_("3939 Could not get dcr\n"));
763 Dmsg1(dbglvl, ">dird: %s", dir->msg);
767 * At this point, we have a list of all the Director's Storage
768 * resources indicated for this Job, which include Pool, PoolType,
769 * storage name, and Media type.
770 * Then for each of the Storage resources, we have a list of
771 * device names that were given.
773 * Wiffle through them and find one that can do the backup.
776 int wait_for_device_retries = 0;
779 rctx.notify_dir = true;
782 for ( ; !fail && !job_canceled(jcr); ) {
783 pop_reserve_messages(jcr);
784 rctx.suitable_device = false;
785 rctx.have_volume = false;
786 rctx.VolumeName[0] = 0;
787 rctx.any_drive = false;
788 if (!jcr->PreferMountedVols) {
790 * Here we try to find a drive that is not used.
791 * This will maximize the use of available drives.
794 rctx.num_writers = 20000000; /* start with impossible number */
795 rctx.low_use_drive = NULL;
796 rctx.PreferMountedVols = false;
797 rctx.exact_match = false;
798 rctx.autochanger_only = true;
799 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
802 /* Look through all drives possibly for low_use drive */
803 if (rctx.low_use_drive) {
804 rctx.try_low_use_drive = true;
805 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
808 rctx.try_low_use_drive = false;
810 rctx.autochanger_only = false;
811 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
816 * Now we look for a drive that may or may not be in
819 /* Look for an exact Volume match all drives */
820 rctx.PreferMountedVols = true;
821 rctx.exact_match = true;
822 rctx.autochanger_only = false;
823 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
826 /* Look for any mounted drive */
827 rctx.exact_match = false;
828 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
832 rctx.any_drive = true;
833 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
836 /* Keep reservations locked *except* during wait_for_device() */
837 unlock_reservations();
839 * The idea of looping on repeat a few times it to ensure
840 * that if there is some subtle timing problem between two
841 * jobs, we will simply try again, and most likely succeed.
842 * This can happen if one job reserves a drive or finishes using
843 * a drive at the same time a second job wants it.
845 if (repeat++ > 1) { /* try algorithm 3 times */
846 bmicrosleep(30, 0); /* wait a bit */
847 Dmsg0(dbglvl, "repeat reserve algorithm\n");
848 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
849 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
853 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
855 unlock_reservations();
858 * If we get here, there are no suitable devices available, which
859 * means nothing configured. If a device is suitable but busy
860 * with another Volume, we will not come here.
862 unbash_spaces(dir->msg);
863 pm_strcpy(jcr->errmsg, dir->msg);
864 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
865 Jmsg(jcr, M_FATAL, 0, _("\n"
866 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
867 dev_name.c_str(), media_type.c_str());
868 dir->fsend(NO_device, dev_name.c_str());
870 Dmsg1(dbglvl, ">dird: %s", dir->msg);
873 unbash_spaces(dir->msg);
874 pm_strcpy(jcr->errmsg, dir->msg);
875 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
876 dir->fsend(BAD_use, jcr->errmsg);
877 Dmsg1(dbglvl, ">dird: %s", dir->msg);
880 release_reserve_messages(jcr);
886 * Walk through the autochanger resources and check if
887 * the volume is in one of them.
889 * Returns: true if volume is in device
892 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
894 AUTOCHANGER *changer = vol->dev->device->changer_res;
896 /* Find resource, and make sure we were able to open it */
897 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
898 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
901 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
906 * Search for a device suitable for this job.
907 * Note, this routine sets sets rctx.suitable_device if any
908 * device exists within the SD. The device may not be actually
910 * It also returns if it finds a useable device.
912 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
921 dirstore = jcr->write_store;
923 dirstore = jcr->read_store;
925 Dmsg5(dbglvl, "Start find_suit_dev PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
926 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
927 rctx.autochanger_only, rctx.any_drive);
930 * If the appropriate conditions of this if are met, namely that
931 * we are appending and the user wants mounted drive (or we
932 * force try a mounted drive because they are all busy), we
933 * start by looking at all the Volumes in the volume list.
935 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
936 dlist *temp_vol_list, *save_vol_list;
939 Dmsg0(dbglvl, "lock volumes\n");
942 * Create a temporary copy of the volume list. We do this,
943 * to avoid having the volume list locked during the
944 * call to reserve_device(), which would cause a deadlock.
945 * Note, we may want to add an update counter on the vol_list
946 * so that if it is modified while we are traversing the copy
947 * we can take note and act accordingly (probably redo the
948 * search at least a few times).
950 Dmsg0(dbglvl, "duplicate vol list\n");
951 temp_vol_list = New(dlist(vol, &vol->link));
952 foreach_dlist(vol, vol_list) {
954 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
955 memset(tvol, 0, sizeof(VOLRES));
956 tvol->vol_name = bstrdup(vol->vol_name);
957 tvol->dev = vol->dev;
958 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
960 tvol->dev = NULL; /* don't zap dev entry */
962 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
963 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
966 Dmsg0(dbglvl, "unlock volumes\n");
969 /* Look through reserved volumes for one we can use */
970 Dmsg0(dbglvl, "look for vol in vol list\n");
971 foreach_dlist(vol, temp_vol_list) {
973 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
976 /* Check with Director if this Volume is OK */
977 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
978 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
982 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
983 foreach_alist(store, dirstore) {
986 foreach_alist(device_name, store->device) {
987 /* Found a device, try to use it */
988 rctx.device_name = device_name;
989 rctx.device = vol->dev->device;
991 if (vol->dev->is_autochanger()) {
992 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
993 if (!is_vol_in_autochanger(rctx, vol)) {
996 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
997 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
998 vol->dev->device->hdr.name, device_name);
1002 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
1003 rctx.have_volume = true;
1004 /* Try reserving this device and volume */
1005 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
1006 stat = reserve_device(rctx);
1007 if (stat == 1) { /* found available device */
1008 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
1011 } else if (stat == 0) { /* device busy */
1012 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
1014 /* otherwise error */
1015 Dmsg0(dbglvl, "No suitable device found.\n");
1017 rctx.have_volume = false;
1018 rctx.VolumeName[0] = 0;
1027 } /* end for loop over reserved volumes */
1029 Dmsg0(dbglvl, "lock volumes\n");
1031 save_vol_list = vol_list;
1032 vol_list = temp_vol_list;
1033 free_volume_list(); /* release temp_vol_list */
1034 vol_list = save_vol_list;
1035 Dmsg0(dbglvl, "deleted temp vol list\n");
1036 Dmsg0(dbglvl, "unlock volumes\n");
1038 debug_list_volumes("=== After free temp table\n");
1041 Dmsg1(dbglvl, "OK dev found. Vol=%s from in-use vols list\n", rctx.VolumeName);
1046 * No reserved volume we can use, so now search for an available device.
1048 * For each storage device that the user specified, we
1049 * search and see if there is a resource for that device.
1051 foreach_alist(store, dirstore) {
1053 foreach_alist(device_name, store->device) {
1055 rctx.device_name = device_name;
1056 stat = search_res_for_device(rctx);
1057 if (stat == 1) { /* found available device */
1058 Dmsg1(dbglvl, "available device found=%s\n", device_name);
1061 } else if (stat == 0) { /* device busy */
1062 Dmsg1(dbglvl, "No usable device=%s, busy: not use\n", device_name);
1064 /* otherwise error */
1065 Dmsg0(dbglvl, "No usable device found.\n");
1073 Dmsg1(dbglvl, "OK dev found. Vol=%s\n", rctx.VolumeName);
1075 Dmsg0(dbglvl, "Leave find_suit_dev: no dev found.\n");
1081 * Search for a particular storage device with particular storage
1082 * characteristics (MediaType).
1084 int search_res_for_device(RCTX &rctx)
1086 AUTOCHANGER *changer;
1089 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
1090 /* Look through Autochangers first */
1091 foreach_res(changer, R_AUTOCHANGER) {
1092 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
1093 /* Find resource, and make sure we were able to open it */
1094 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1095 /* Try each device in this AutoChanger */
1096 foreach_alist(rctx.device, changer->device) {
1097 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
1098 stat = reserve_device(rctx);
1099 if (stat != 1) { /* try another device */
1103 if (rctx.store->append == SD_APPEND) {
1104 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1105 rctx.device->hdr.name, rctx.jcr->dcr->dev->num_reserved());
1107 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1108 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->num_reserved());
1115 /* Now if requested look through regular devices */
1116 if (!rctx.autochanger_only) {
1117 foreach_res(rctx.device, R_DEVICE) {
1118 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
1119 /* Find resource, and make sure we were able to open it */
1120 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1121 stat = reserve_device(rctx);
1122 if (stat != 1) { /* try another device */
1126 if (rctx.store->append == SD_APPEND) {
1127 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1128 rctx.device->hdr.name, rctx.jcr->dcr->dev->num_reserved());
1130 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1131 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->num_reserved());
1137 return -1; /* nothing found */
1141 * Try to reserve a specific device.
1143 * Returns: 1 -- OK, have DCR
1147 static int reserve_device(RCTX &rctx)
1151 const int name_len = MAX_NAME_LENGTH;
1153 /* Make sure MediaType is OK */
1154 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
1155 rctx.device->media_type, rctx.store->media_type);
1156 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1160 /* Make sure device exists -- i.e. we can stat() it */
1161 if (!rctx.device->dev) {
1162 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1164 if (!rctx.device->dev) {
1165 if (rctx.device->changer_res) {
1166 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1167 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1168 rctx.device->hdr.name, rctx.device_name);
1170 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1171 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1174 return -1; /* no use waiting */
1177 rctx.suitable_device = true;
1178 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1179 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1181 BSOCK *dir = rctx.jcr->dir_bsock;
1182 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1183 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1186 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1187 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1188 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1189 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1190 if (rctx.store->append == SD_APPEND) {
1191 Dmsg2(dbglvl, "call reserve for append: have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
1192 ok = reserve_device_for_append(dcr, rctx);
1197 rctx.jcr->dcr = dcr;
1198 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1199 dcr->dev->num_reserved(),
1200 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1201 Dmsg3(dbglvl, "Vol=%s num_writers=%d, have_vol=%d\n",
1202 rctx.VolumeName, dcr->dev->num_writers, rctx.have_volume);
1203 if (rctx.have_volume) {
1204 Dmsg0(dbglvl, "Call reserve_volume\n");
1205 if (reserve_volume(dcr, rctx.VolumeName)) {
1206 Dmsg1(dbglvl, "Reserved vol=%s\n", rctx.VolumeName);
1208 Dmsg1(dbglvl, "Could not reserve vol=%s\n", rctx.VolumeName);
1212 dcr->any_volume = true;
1213 Dmsg0(dbglvl, "no vol, call find_next_appendable_vol.\n");
1214 if (dir_find_next_appendable_volume(dcr)) {
1215 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1216 rctx.have_volume = true;
1217 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
1219 Dmsg0(dbglvl, "No next volume found\n");
1220 rctx.have_volume = false;
1221 rctx.VolumeName[0] = 0;
1223 * If there is at least one volume that is valid and in use,
1224 * but we get here, check if we are running with prefers
1225 * non-mounted drives. In that case, we have selected a
1226 * non-used drive and our one and only volume is mounted
1227 * elsewhere, so we bail out and retry using that drive.
1229 if (dcr->found_in_use() && !rctx.PreferMountedVols) {
1230 rctx.PreferMountedVols = true;
1231 if (dcr->VolumeName[0]) {
1232 dcr->unreserve_device();
1237 * Note. Under some circumstances, the Director can hand us
1238 * a Volume name that is not the same as the one on the current
1239 * drive, and in that case, the call above to find the next
1240 * volume will fail because in attempting to reserve the Volume
1241 * the code will realize that we already have a tape mounted,
1242 * and it will fail. This *should* only happen if there are
1243 * writers, thus the following test. In that case, we simply
1244 * bail out, and continue waiting, rather than plunging on
1245 * and hoping that the operator can resolve the problem.
1247 if (dcr->dev->num_writers != 0) {
1248 if (dcr->VolumeName[0]) {
1249 dcr->unreserve_device();
1256 ok = reserve_device_for_read(dcr);
1258 rctx.jcr->read_dcr = dcr;
1259 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1260 dcr->dev->num_reserved(),
1261 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1268 if (rctx.notify_dir) {
1270 BSOCK *dir = rctx.jcr->dir_bsock;
1271 pm_strcpy(dev_name, rctx.device->hdr.name);
1272 bash_spaces(dev_name);
1273 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1274 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1281 rctx.have_volume = false;
1282 rctx.VolumeName[0] = 0;
1283 Dmsg0(dbglvl, "Not OK.\n");
1288 * We "reserve" the drive by setting the ST_READ bit. No one else
1289 * should touch the drive until that is cleared.
1290 * This allows the DIR to "reserve" the device before actually
1293 static bool reserve_device_for_read(DCR *dcr)
1295 DEVICE *dev = dcr->dev;
1296 JCR *jcr = dcr->jcr;
1303 if (is_device_unmounted(dev)) {
1304 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
1305 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1306 jcr->JobId, dev->print_name());
1307 queue_reserve_message(jcr);
1311 if (dev->is_busy()) {
1312 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1314 dev->state & ST_READ?1:0, dev->num_writers, dev->num_reserved());
1315 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1316 jcr->JobId, dev->print_name());
1317 queue_reserve_message(jcr);
1321 dev->clear_append();
1324 dcr->set_reserved();
1333 * We reserve the device for appending by incrementing the
1334 * reserved_device. We do virtually all the same work that
1335 * is done in acquire_device_for_append(), but we do
1336 * not attempt to mount the device. This routine allows
1337 * the DIR to reserve multiple devices before *really*
1338 * starting the job. It also permits the SD to refuse
1339 * certain devices (not up, ...).
1341 * Note, in reserving a device, if the device is for the
1342 * same pool and the same pool type, then it is acceptable.
1343 * The Media Type has already been checked. If we are
1344 * the first tor reserve the device, we put the pool
1345 * name and pool type in the device record.
1347 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1349 JCR *jcr = dcr->jcr;
1350 DEVICE *dev = dcr->dev;
1357 /* If device is being read, we cannot write it */
1358 if (dev->can_read()) {
1359 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1360 jcr->JobId, dev->print_name());
1361 Dmsg1(dbglvl, "%s", jcr->errmsg);
1362 queue_reserve_message(jcr);
1366 /* If device is unmounted, we are out of luck */
1367 if (is_device_unmounted(dev)) {
1368 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1369 jcr->JobId, dev->print_name());
1370 Dmsg1(dbglvl, "%s", jcr->errmsg);
1371 queue_reserve_message(jcr);
1375 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
1377 /* Now do detailed tests ... */
1378 if (can_reserve_drive(dcr, rctx) != 1) {
1379 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
1383 dcr->set_reserved();
1391 static int is_pool_ok(DCR *dcr)
1393 DEVICE *dev = dcr->dev;
1394 JCR *jcr = dcr->jcr;
1396 /* Now check if we want the same Pool and pool type */
1397 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1398 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1399 /* OK, compatible device */
1400 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1403 /* Drive Pool not suitable for us */
1404 Mmsg(jcr->errmsg, _(
1405 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1406 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1407 dev->num_reserved(), dev->print_name());
1408 queue_reserve_message(jcr);
1409 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1410 dev->pool_name, dcr->pool_name);
1415 static bool is_max_jobs_ok(DCR *dcr)
1417 DEVICE *dev = dcr->dev;
1418 JCR *jcr = dcr->jcr;
1420 Dmsg5(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Status=%s Vol=%s\n",
1421 dcr->VolCatInfo.VolCatMaxJobs,
1422 dcr->VolCatInfo.VolCatJobs, dev->num_reserved(),
1423 dcr->VolCatInfo.VolCatStatus,
1425 if (strcmp(dcr->VolCatInfo.VolCatStatus, "Recycle") == 0) {
1428 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1429 (dcr->VolCatInfo.VolCatJobs + dev->num_reserved())) {
1430 /* Max Job Vols depassed or already reserved */
1431 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1432 (uint32_t)jcr->JobId, dev->print_name());
1433 queue_reserve_message(jcr);
1434 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1435 return false; /* wait */
1441 * Returns: 1 if drive can be reserved
1442 * 0 if we should wait
1443 * -1 on error or impossibility
1445 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1447 DEVICE *dev = dcr->dev;
1448 JCR *jcr = dcr->jcr;
1450 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1451 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1452 rctx.autochanger_only, rctx.any_drive);
1454 /* Check for max jobs on this Volume */
1455 if (!is_max_jobs_ok(dcr)) {
1459 /* setting any_drive overrides PreferMountedVols flag */
1460 if (!rctx.any_drive) {
1462 * When PreferMountedVols is set, we keep track of the
1463 * drive in use that has the least number of writers, then if
1464 * no unmounted drive is found, we try that drive. This
1465 * helps spread the load to the least used drives.
1467 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1468 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
1469 dev->print_name(), rctx.low_use_drive->print_name());
1472 /* If he wants a free drive, but this one is busy, no go */
1473 if (!rctx.PreferMountedVols && dev->is_busy()) {
1474 /* Save least used drive */
1475 if ((dev->num_writers + dev->num_reserved()) < rctx.num_writers) {
1476 rctx.num_writers = dev->num_writers + dev->num_reserved();
1477 rctx.low_use_drive = dev;
1478 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
1479 dev->print_name(), rctx.num_writers);
1481 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->num_reserved());
1483 Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
1484 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1485 jcr->JobId, dev->print_name());
1486 queue_reserve_message(jcr);
1490 /* Check for prefer mounted volumes */
1491 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1492 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1493 jcr->JobId, dev->print_name());
1494 queue_reserve_message(jcr);
1495 Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
1496 return 0; /* No volume mounted */
1499 /* Check for exact Volume name match */
1500 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1503 if (rctx.exact_match && rctx.have_volume) {
1505 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1506 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1507 rctx.autochanger_only, rctx.any_drive);
1508 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1509 rctx.have_volume, dev->VolHdr.VolumeName,
1510 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1511 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1512 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1514 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1515 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1517 queue_reserve_message(jcr);
1518 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1519 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1522 if (!dcr->can_i_use_volume()) {
1523 return 0; /* fail if volume on another drive */
1528 /* Check for unused autochanger drive */
1529 if (rctx.autochanger_only && !dev->is_busy() &&
1530 dev->VolHdr.VolumeName[0] == 0) {
1531 /* Device is available but not yet reserved, reserve it for us */
1532 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1533 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1534 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1535 return 1; /* reserve drive */
1539 * Handle the case that there are no writers
1541 if (dev->num_writers == 0) {
1542 /* Now check if there are any reservations on the drive */
1543 if (dev->num_reserved()) {
1544 return is_pool_ok(dcr);
1545 } else if (dev->can_append()) {
1546 if (is_pool_ok(dcr)) {
1549 /* Changing pool, unload old tape if any in drive */
1550 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1551 /* ***FIXME*** use set_unload() */
1552 unload_autochanger(dcr, 0);
1555 /* Device is available but not yet reserved, reserve it for us */
1556 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1557 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1558 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1559 return 1; /* reserve drive */
1563 * Check if the device is in append mode with writers (i.e.
1564 * available if pool is the same).
1566 if (dev->can_append() || dev->num_writers > 0) {
1567 return is_pool_ok(dcr);
1569 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1570 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1571 jcr->JobId, dev->print_name());
1572 queue_reserve_message(jcr);
1573 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1574 return -1; /* error, should not get here */
1576 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1577 jcr->JobId, dev->print_name());
1578 queue_reserve_message(jcr);
1579 Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1587 * Queue a reservation error or failure message for this jcr
1589 static void queue_reserve_message(JCR *jcr)
1597 msgs = jcr->reserve_msgs;
1602 * Look for duplicate message. If found, do
1605 for (i=msgs->size()-1; i >= 0; i--) {
1606 msg = (char *)msgs->get(i);
1610 /* Comparison based on 4 digit message number */
1611 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1615 /* Message unique, so insert it */
1616 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1623 * Send any reservation messages queued for this jcr
1625 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1632 msgs = jcr->reserve_msgs;
1633 if (!msgs || msgs->size() == 0) {
1636 for (i=msgs->size()-1; i >= 0; i--) {
1637 msg = (char *)msgs->get(i);
1639 sendit(" ", 3, arg);
1640 sendit(msg, strlen(msg), arg);
1651 * Pop and release any reservations messages
1653 static void pop_reserve_messages(JCR *jcr)
1659 msgs = jcr->reserve_msgs;
1663 while ((msg = (char *)msgs->pop())) {
1671 * Also called from acquire.c
1673 void release_reserve_messages(JCR *jcr)
1675 pop_reserve_messages(jcr);
1677 if (!jcr->reserve_msgs) {
1680 delete jcr->reserve_msgs;
1681 jcr->reserve_msgs = NULL;