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 reserved=%d on device %s\n", imsg,
182 vol->vol_name, vol->is_reserved(), vol->dev->print_name());
184 Mmsg(msg, "List %s: %s reserved=%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 volres=%d\n",
221 dev->can_read()?1:0, dev->num_writers, dev->reserved_device,
223 sendit(msg.c_str(), len, arg);
225 len = Mmsg(msg, "%s no device. volres= %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)
265 * Put a new Volume entry in the Volume list. This
266 * effectively reserves the volume so that it will
267 * not be mounted again.
269 * If the device has any current volume associated with it,
270 * and it is a different Volume, and the device is not busy,
271 * we release the old Volume item and insert the new one.
273 * It is assumed that the device is free and locked so that
274 * we can change the device structure.
276 * Some details of the Volume list handling:
278 * 1. The Volume list entry must be attached to the drive (rather than
279 * attached to a job as it currently is. I.e. the drive that "owns"
280 * the volume (reserved, in use, mounted)
281 * must point to the volume (still to be maintained in a list).
283 * 2. The Volume is entered in the list when a drive is reserved.
285 * 3. When a drive is in use, the device code must appropriately update the
286 * volume name as it changes (currently the list is static -- an entry is
287 * removed when the Volume is no longer reserved, in use or mounted).
288 * The new code must keep the same list entry as long as the drive
289 * has any volume associated with it but the volume name in the list
290 * must be updated when the drive has a different volume mounted.
292 * 4. A job that has reserved a volume, can un-reserve the volume, and if the
293 * volume is not mounted, and not reserved, and not in use, it will be
294 * removed from the list.
296 * 5. If a job wants to reserve a drive with a different Volume from the one on
297 * the drive, it can re-use the drive for the new Volume.
299 * 6. If a job wants a Volume that is in a different drive, it can either use the
300 * other drive or take the volume, only if the other drive is not in use or
303 * One nice aspect of this is that the reserve use count and the writer use count
304 * already exist and are correctly programmed and will need no changes -- use
305 * counts are always very tricky.
307 * The old code had a concept of "reserving" a Volume, but was changed
308 * to reserving and using a drive. A volume is must be attached to (owned by) a
309 * drive and can move from drive to drive or be unused given certain specific
310 * conditions of the drive. The key is that the drive must "own" the Volume.
311 * The old code had the job (dcr) owning the volume (more or less). The job was
312 * to change the insertion and removal of the volumes from the list to be based
313 * on the drive rather than the job.
315 * Return: VOLRES entry on success
316 * NULL volume busy on another drive
318 VOLRES *reserve_volume(DCR *dcr, const char *VolumeName)
321 DEVICE * volatile dev = dcr->dev;
325 Dmsg2(dbglvl, "enter reserve_volume=%s drive=%s\n", VolumeName,
326 dcr->dev->print_name());
328 * We lock the reservations system here to ensure
329 * when adding a new volume that no newly scheduled
330 * job can reserve it.
333 debug_list_volumes("begin reserve_volume");
335 * First, remove any old volume attached to this device as it
340 Dmsg4(dbglvl, "Vol attached=%s, newvol=%s volres=%d on %s\n",
341 vol->vol_name, VolumeName, vol->is_reserved(), dev->print_name());
343 * Make sure we don't remove the current volume we are inserting
344 * because it was probably inserted by another job, or it
345 * is not being used and is marked as not reserved.
347 if (strcmp(vol->vol_name, VolumeName) == 0) {
348 Dmsg2(dbglvl, "=== set reserved vol=%s dev=%s\n", VolumeName,
349 vol->dev->print_name());
350 vol->set_reserved(); /* retake vol if released previously */
351 dcr->reserved_volume = true; /* reserved volume */
352 goto get_out; /* Volume already on this device */
354 /* Don't release a volume if it was reserved by someone other than us */
355 if (vol->is_reserved() && !dcr->reserved_volume) {
356 Dmsg1(dbglvl, "Cannot free vol=%s. It is reserved.\n", vol->vol_name);
357 vol = NULL; /* vol in use */
360 Dmsg2(dbglvl, "reserve_vol free vol=%s at %p\n", vol->vol_name, vol->vol_name);
362 dcr->unload_device = true; /* have to unload current volume */
363 debug_list_volumes("reserve_vol free");
367 /* Create a new Volume entry */
368 nvol = new_vol_item(dcr, VolumeName);
371 * Now try to insert the new Volume
373 vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
375 Dmsg2(dbglvl, "Found vol=%s dev-same=%d\n", vol->vol_name, dev==vol->dev);
377 * At this point, a Volume with this name already is in the list,
378 * so we simply release our new Volume entry. Note, this should
379 * only happen if we are moving the volume from one drive to another.
381 Dmsg2(dbglvl, "reserve_vol free-tmp vol=%s at %p\n",
382 vol->vol_name, vol->vol_name);
384 * Clear dev pointer so that free_vol_item() doesn't
385 * take away our volume.
387 nvol->dev = NULL; /* don't zap dev entry */
390 /* Check if we are trying to use the Volume on a different drive */
391 if (dev != vol->dev) {
392 /* Caller wants to switch Volume to another device */
393 /* ***FIXME*** don't let vol being swapped be stolen */
394 if (!vol->dev->is_busy()) {
396 dcr->swap_dev = vol->dev; /* remember to get this vol */
397 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n",
398 VolumeName, vol->dev->print_name(), dev->print_name());
400 Dmsg3(dbglvl, "==== Swap not possible Vol busy vol=%s from dev=%s to %s\n",
401 VolumeName, vol->dev->print_name(), dev->print_name());
402 vol = NULL; /* device busy */
409 dev->vol = vol; /* point to newly inserted volume */
414 Dmsg2(dbglvl, "=== set reserved. vol=%s dev=%s\n", vol->vol_name,
415 vol->dev->print_name());
417 dcr->reserved_volume = true;
419 debug_list_volumes("end new volume");
425 * Switch from current device to given device
428 void switch_device(DCR *dcr, DEVICE *dev)
433 memcpy(&save_dcr, dcr, sizeof(save_dcr));
434 clean_device(dcr); /* clean up the dcr */
436 dcr->dev = dev; /* get new device pointer */
437 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
438 dcr->dev->print_name());
440 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
441 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
442 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
443 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
444 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
445 bstrncpy(dcr->dev_name, dev->dev_name, sizeof(dcr->dev_name));
447 dev->reserved_device++;
448 dcr->reserved_device = true;
454 * Search for a Volume name in the Volume list.
456 * Returns: VOLRES entry on success
457 * NULL if the Volume is not in the list
459 VOLRES *find_volume(DCR *dcr)
462 /* Do not lock reservations here */
464 vol.vol_name = bstrdup(dcr->VolumeName);
465 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
467 Dmsg2(dbglvl, "find_vol=%s found=%d\n", dcr->VolumeName, fvol!=NULL);
468 debug_list_volumes("find_volume");
474 * Remove any reservation from a drive and tell the system
475 * that the volume is unused at least by us.
477 void unreserve_device(DCR *dcr)
479 DEVICE *dev = dcr->dev;
481 if (dcr->reserved_device) {
482 dcr->reserved_device = false;
483 dcr->reserved_volume = false;
484 dev->reserved_device--;
485 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name());
486 /* If we set read mode in reserving, remove it */
487 if (dev->can_read()) {
490 if (dev->num_writers < 0) {
491 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
492 dev->num_writers = 0;
494 if (dev->reserved_device == 0 && dev->num_writers == 0) {
502 * Free a Volume from the Volume list if it is no longer used
503 * Note, for tape drives we want to remember where the Volume
504 * was when last used, so rather than free the volume entry,
505 * we simply mark it "not reserved" so when the drive is really
506 * needed for another volume, we can reuse it.
508 * Returns: true if the Volume found and "removed" from the list
509 * false if the Volume is not in the list or is in use
511 bool volume_unused(DCR *dcr)
513 DEVICE *dev = dcr->dev;
516 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
517 debug_list_volumes("null vol cannot unreserve_volume");
520 if (dev->vol->is_swapping()) {
521 Dmsg1(dbglvl, "vol_unused: vol being swapped on %s\n", dev->print_name());
522 debug_list_volumes("swapping vol cannot unreserve_volume");
527 if (dev->is_busy()) {
528 Dmsg1(dbglvl, "vol_unused: busy on %s\n", dev->print_name());
529 debug_list_volumes("dev busy cannot unreserve_volume");
534 if (dev->num_writers > 0 || dev->reserved_device > 0) {
540 * If this is a tape, we do not free the volume, rather we wait
541 * until the autoloader unloads it, or until another tape is
542 * explicitly read in this drive. This allows the SD to remember
543 * where the tapes are or last were.
545 Dmsg3(dbglvl, "=== mark not reserved vol=%s num_writers=%d dev_reserved=%d\n",
546 dev->vol->vol_name, dev->num_writers, dev->reserved_device);
547 dev->vol->clear_reserved();
548 Dmsg2(dbglvl, "=== set not reserved. Vol=%s dev=%s\n", dev->vol->vol_name,
550 if (dev->is_tape() || dev->is_autochanger()) {
554 * Note, this frees the volume reservation entry, but the
555 * file descriptor remains open with the OS.
557 return free_volume(dev);
562 * Unconditionally release the volume entry
564 bool free_volume(DEVICE *dev)
568 if (dev->vol == NULL) {
569 Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name());
575 vol_list->remove(vol);
576 Dmsg2(dbglvl, "=== free_volume %s dev=%s\n", vol->vol_name, dev->print_name());
578 debug_list_volumes("free_volume");
584 /* Create the Volume list */
585 void create_volume_list()
588 if (vol_list == NULL) {
589 vol_list = New(dlist(vol, &vol->link));
593 /* Release all Volumes from the list */
594 void free_volume_list()
601 foreach_dlist(vol, vol_list) {
603 Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name());
605 Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name);
608 vol->vol_name = NULL;
615 bool is_volume_in_use(DCR *dcr)
621 vol = find_volume(dcr);
623 Dmsg1(dbglvl, "Vol=%s not in use.\n", dcr->VolumeName);
624 goto get_out; /* vol not in list */
626 ASSERT(vol->dev != NULL);
628 if (dcr->dev == vol->dev) { /* same device OK */
629 Dmsg1(dbglvl, "Vol=%s on same dev.\n", dcr->VolumeName);
632 Dmsg3(dbglvl, "Vol=%s on %s we have %s\n", dcr->VolumeName,
633 vol->dev->print_name(), dcr->dev->print_name());
635 if (!vol->dev->is_busy()) {
636 Dmsg2(dbglvl, "Vol=%s dev=%s not busy.\n", dcr->VolumeName, vol->dev->print_name());
639 Dmsg2(dbglvl, "Vol=%s dev=%s busy.\n", dcr->VolumeName, vol->dev->print_name());
641 Dmsg2(dbglvl, "Vol=%s in use by %s.\n", dcr->VolumeName, vol->dev->print_name());
652 * We get the following type of information:
654 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
658 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
662 static bool use_storage_cmd(JCR *jcr)
664 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
665 BSOCK *dir = jcr->dir_bsock;
673 memset(&rctx, 0, sizeof(RCTX));
676 * If there are multiple devices, the director sends us
677 * use_device for each device that it wants to use.
679 dirstore = New(alist(10, not_owned_by_alist));
680 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
682 Dmsg1(dbglvl, "<dird: %s", dir->msg);
683 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
684 media_type.c_str(), pool_name.c_str(),
685 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
690 jcr->write_store = dirstore;
692 jcr->read_store = dirstore;
694 rctx.append = append;
695 unbash_spaces(store_name);
696 unbash_spaces(media_type);
697 unbash_spaces(pool_name);
698 unbash_spaces(pool_type);
699 store = new DIRSTORE;
700 dirstore->append(store);
701 memset(store, 0, sizeof(DIRSTORE));
702 store->device = New(alist(10));
703 bstrncpy(store->name, store_name, sizeof(store->name));
704 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
705 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
706 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
707 store->append = append;
709 /* Now get all devices */
710 while (dir->recv() >= 0) {
711 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
712 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
716 unbash_spaces(dev_name);
717 store->device->append(bstrdup(dev_name.c_str()));
719 } while (ok && dir->recv() >= 0);
721 /* Developer debug code */
723 if (debug_level >= dbglvl) {
724 foreach_alist(store, dirstore) {
725 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
726 store->name, store->media_type, store->pool_name,
727 store->pool_type, store->append);
728 foreach_alist(device_name, store->device) {
729 Dmsg1(dbglvl, " Device=%s\n", device_name);
734 init_jcr_device_wait_timers(jcr);
735 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
737 BSOCK *dir = jcr->dir_bsock;
738 dir->fsend(_("3939 Could not get dcr\n"));
739 Dmsg1(dbglvl, ">dird: %s", dir->msg);
743 * At this point, we have a list of all the Director's Storage
744 * resources indicated for this Job, which include Pool, PoolType,
745 * storage name, and Media type.
746 * Then for each of the Storage resources, we have a list of
747 * device names that were given.
749 * Wiffle through them and find one that can do the backup.
752 int wait_for_device_retries = 0;
755 rctx.notify_dir = true;
758 for ( ; !fail && !job_canceled(jcr); ) {
759 pop_reserve_messages(jcr);
760 rctx.suitable_device = false;
761 rctx.have_volume = false;
762 rctx.VolumeName[0] = 0;
763 rctx.any_drive = false;
764 if (!jcr->PreferMountedVols) {
766 * Here we try to find a drive that is not used.
767 * This will maximize the use of available drives.
770 rctx.num_writers = 20000000; /* start with impossible number */
771 rctx.low_use_drive = NULL;
772 rctx.PreferMountedVols = false;
773 rctx.exact_match = false;
774 rctx.autochanger_only = true;
775 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
776 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
777 rctx.autochanger_only, rctx.any_drive);
778 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
781 /* Look through all drives possibly for low_use drive */
782 if (rctx.low_use_drive) {
783 rctx.try_low_use_drive = true;
784 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
787 rctx.try_low_use_drive = false;
789 rctx.autochanger_only = false;
790 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
791 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
792 rctx.autochanger_only, rctx.any_drive);
793 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
798 * Now we look for a drive that may or may not be in
801 /* Look for an exact Volume match all drives */
802 rctx.PreferMountedVols = true;
803 rctx.exact_match = true;
804 rctx.autochanger_only = false;
805 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
806 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
807 rctx.autochanger_only, rctx.any_drive);
808 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
811 /* Look for any mounted drive */
812 rctx.exact_match = false;
813 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
814 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
815 rctx.autochanger_only, rctx.any_drive);
816 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
820 rctx.any_drive = true;
821 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
822 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
823 rctx.autochanger_only, rctx.any_drive);
824 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
827 /* Keep reservations locked *except* during wait_for_device() */
828 unlock_reservations();
830 * The idea of looping on repeat a few times it to ensure
831 * that if there is some subtle timing problem between two
832 * jobs, we will simply try again, and most likely succeed.
833 * This can happen if one job reserves a drive or finishes using
834 * a drive at the same time a second job wants it.
836 if (repeat++ > 1) { /* try algorithm 3 times */
837 bmicrosleep(30, 0); /* wait a bit */
838 Dmsg0(dbglvl, "repeat reserve algorithm\n");
839 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
840 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
844 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
846 unlock_reservations();
849 * If we get here, there are no suitable devices available, which
850 * means nothing configured. If a device is suitable but busy
851 * with another Volume, we will not come here.
853 unbash_spaces(dir->msg);
854 pm_strcpy(jcr->errmsg, dir->msg);
855 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
856 Jmsg(jcr, M_FATAL, 0, _("\n"
857 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
858 dev_name.c_str(), media_type.c_str());
859 dir->fsend(NO_device, dev_name.c_str());
861 Dmsg1(dbglvl, ">dird: %s", dir->msg);
864 unbash_spaces(dir->msg);
865 pm_strcpy(jcr->errmsg, dir->msg);
866 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
867 dir->fsend(BAD_use, jcr->errmsg);
868 Dmsg1(dbglvl, ">dird: %s", dir->msg);
871 release_reserve_messages(jcr);
877 * Walk through the autochanger resources and check if
878 * the volume is in one of them.
880 * Returns: true if volume is in device
883 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
885 AUTOCHANGER *changer = vol->dev->device->changer_res;
887 /* Find resource, and make sure we were able to open it */
888 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
889 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
892 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
897 * Search for a device suitable for this job.
898 * Note, this routine sets sets rctx.suitable_device if any
899 * device exists within the SD. The device may not be actually
901 * It also returns if it finds a useable device.
903 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
912 dirstore = jcr->write_store;
914 dirstore = jcr->read_store;
916 Dmsg4(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
917 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
918 rctx.autochanger_only);
921 * If the appropriate conditions of this if are met, namely that
922 * we are appending and the user wants mounted drive (or we
923 * force try a mounted drive because they are all busy), we
924 * start by looking at all the Volumes in the volume list.
926 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
927 dlist *temp_vol_list, *save_vol_list;
930 Dmsg0(dbglvl, "lock volumes\n");
933 * Create a temporary copy of the volume list. We do this,
934 * to avoid having the volume list locked during the
935 * call to reserve_device(), which would cause a deadlock.
936 * Note, we may want to add an update counter on the vol_list
937 * so that if it is modified while we are traversing the copy
938 * we can take note and act accordingly (probably redo the
939 * search at least a few times).
941 Dmsg0(dbglvl, "duplicate vol list\n");
942 temp_vol_list = New(dlist(vol, &vol->link));
943 foreach_dlist(vol, vol_list) {
945 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
946 memset(tvol, 0, sizeof(VOLRES));
947 tvol->vol_name = bstrdup(vol->vol_name);
948 tvol->dev = vol->dev;
949 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
951 tvol->dev = NULL; /* don't zap dev entry */
953 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
954 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
957 Dmsg0(dbglvl, "unlock volumes\n");
960 /* Look through reserved volumes for one we can use */
961 Dmsg0(dbglvl, "look for vol in vol list\n");
962 foreach_dlist(vol, temp_vol_list) {
964 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
967 /* Check with Director if this Volume is OK */
968 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
969 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
973 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
974 foreach_alist(store, dirstore) {
977 foreach_alist(device_name, store->device) {
978 /* Found a device, try to use it */
979 rctx.device_name = device_name;
980 rctx.device = vol->dev->device;
982 if (vol->dev->is_autochanger()) {
983 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
984 if (!is_vol_in_autochanger(rctx, vol)) {
987 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
988 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
989 vol->dev->device->hdr.name, device_name);
993 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
994 rctx.have_volume = true;
995 /* Try reserving this device and volume */
996 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
997 stat = reserve_device(rctx);
998 if (stat == 1) { /* found available device */
999 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
1002 } else if (stat == 0) { /* device busy */
1003 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
1005 /* otherwise error */
1006 Dmsg0(dbglvl, "No suitable device found.\n");
1008 rctx.have_volume = false;
1009 rctx.VolumeName[0] = 0;
1018 } /* end for loop over reserved volumes */
1020 Dmsg0(dbglvl, "lock volumes\n");
1022 save_vol_list = vol_list;
1023 vol_list = temp_vol_list;
1024 free_volume_list(); /* release temp_vol_list */
1025 vol_list = save_vol_list;
1026 Dmsg0(dbglvl, "deleted temp vol list\n");
1027 Dmsg0(dbglvl, "unlock volumes\n");
1029 debug_list_volumes("=== After free temp table\n");
1032 Dmsg1(dbglvl, "Usable dev found. Vol=%s from in-use vols list\n", rctx.VolumeName);
1037 * No reserved volume we can use, so now search for an available device.
1039 * For each storage device that the user specified, we
1040 * search and see if there is a resource for that device.
1042 foreach_alist(store, dirstore) {
1044 foreach_alist(device_name, store->device) {
1046 rctx.device_name = device_name;
1047 stat = search_res_for_device(rctx);
1048 if (stat == 1) { /* found available device */
1049 Dmsg1(dbglvl, "available device found=%s\n", device_name);
1052 } else if (stat == 0) { /* device busy */
1053 Dmsg1(dbglvl, "No usable device=%s, busy: not use\n", device_name);
1055 /* otherwise error */
1056 Dmsg0(dbglvl, "No usable device found.\n");
1064 Dmsg1(dbglvl, "Usable dev found. Vol=%s\n", rctx.VolumeName);
1070 * Search for a particular storage device with particular storage
1071 * characteristics (MediaType).
1073 int search_res_for_device(RCTX &rctx)
1075 AUTOCHANGER *changer;
1078 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
1079 /* Look through Autochangers first */
1080 foreach_res(changer, R_AUTOCHANGER) {
1081 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
1082 /* Find resource, and make sure we were able to open it */
1083 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1084 /* Try each device in this AutoChanger */
1085 foreach_alist(rctx.device, changer->device) {
1086 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
1087 stat = reserve_device(rctx);
1088 if (stat != 1) { /* try another device */
1092 if (rctx.store->append == SD_APPEND) {
1093 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1094 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1096 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1097 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1104 /* Now if requested look through regular devices */
1105 if (!rctx.autochanger_only) {
1106 foreach_res(rctx.device, R_DEVICE) {
1107 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
1108 /* Find resource, and make sure we were able to open it */
1109 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1110 stat = reserve_device(rctx);
1111 if (stat != 1) { /* try another device */
1115 if (rctx.store->append == SD_APPEND) {
1116 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1117 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1119 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1120 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1126 return -1; /* nothing found */
1130 * Try to reserve a specific device.
1132 * Returns: 1 -- OK, have DCR
1136 static int reserve_device(RCTX &rctx)
1140 const int name_len = MAX_NAME_LENGTH;
1142 /* Make sure MediaType is OK */
1143 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
1144 rctx.device->media_type, rctx.store->media_type);
1145 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1149 /* Make sure device exists -- i.e. we can stat() it */
1150 if (!rctx.device->dev) {
1151 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1153 if (!rctx.device->dev) {
1154 if (rctx.device->changer_res) {
1155 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1156 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1157 rctx.device->hdr.name, rctx.device_name);
1159 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1160 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1163 return -1; /* no use waiting */
1166 rctx.suitable_device = true;
1167 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1168 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1170 BSOCK *dir = rctx.jcr->dir_bsock;
1171 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1172 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1175 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1176 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1177 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1178 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1179 if (rctx.store->append == SD_APPEND) {
1180 Dmsg2(dbglvl, "call reserve for append: have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
1181 ok = reserve_device_for_append(dcr, rctx);
1186 rctx.jcr->dcr = dcr;
1187 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1188 dcr->dev->reserved_device,
1189 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1190 Dmsg3(dbglvl, "Vol=%s num_writers=%d, have_vol=%d\n",
1191 rctx.VolumeName, dcr->dev->num_writers, rctx.have_volume);
1192 if (rctx.have_volume) {
1193 Dmsg0(dbglvl, "Call reserve_volume\n");
1194 if (reserve_volume(dcr, rctx.VolumeName)) {
1195 Dmsg1(dbglvl, "Reserved vol=%s\n", rctx.VolumeName);
1197 Dmsg1(dbglvl, "Could not reserve vol=%s\n", rctx.VolumeName);
1201 dcr->any_volume = true;
1202 Dmsg0(dbglvl, "no vol, call find_next_appendable_vol.\n");
1203 if (dir_find_next_appendable_volume(dcr)) {
1204 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1205 rctx.have_volume = true;
1206 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
1208 Dmsg0(dbglvl, "No next volume found\n");
1209 rctx.have_volume = false;
1210 rctx.VolumeName[0] = 0;
1212 * If there is at least one volume that is valid and in use,
1213 * but we get here, check if we are running with prefers
1214 * non-mounted drives. In that case, we have selected a
1215 * non-used drive and our one and only volume is mounted
1216 * elsewhere, so we bail out and retry using that drive.
1218 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1219 rctx.PreferMountedVols = true;
1220 if (dcr->VolumeName[0]) {
1221 unreserve_device(dcr);
1226 * Note. Under some circumstances, the Director can hand us
1227 * a Volume name that is not the same as the one on the current
1228 * drive, and in that case, the call above to find the next
1229 * volume will fail because in attempting to reserve the Volume
1230 * the code will realize that we already have a tape mounted,
1231 * and it will fail. This *should* only happen if there are
1232 * writers, thus the following test. In that case, we simply
1233 * bail out, and continue waiting, rather than plunging on
1234 * and hoping that the operator can resolve the problem.
1236 if (dcr->dev->num_writers != 0) {
1237 if (dcr->VolumeName[0]) {
1238 unreserve_device(dcr);
1245 ok = reserve_device_for_read(dcr);
1247 rctx.jcr->read_dcr = dcr;
1248 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1249 dcr->dev->reserved_device,
1250 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1257 if (rctx.notify_dir) {
1259 BSOCK *dir = rctx.jcr->dir_bsock;
1260 pm_strcpy(dev_name, rctx.device->hdr.name);
1261 bash_spaces(dev_name);
1262 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1263 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1270 rctx.have_volume = false;
1271 rctx.VolumeName[0] = 0;
1272 Dmsg0(dbglvl, "Not OK.\n");
1277 * We "reserve" the drive by setting the ST_READ bit. No one else
1278 * should touch the drive until that is cleared.
1279 * This allows the DIR to "reserve" the device before actually
1282 static bool reserve_device_for_read(DCR *dcr)
1284 DEVICE *dev = dcr->dev;
1285 JCR *jcr = dcr->jcr;
1292 if (is_device_unmounted(dev)) {
1293 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
1294 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1295 jcr->JobId, dev->print_name());
1296 queue_reserve_message(jcr);
1300 if (dev->is_busy()) {
1301 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1303 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1304 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1305 jcr->JobId, dev->print_name());
1306 queue_reserve_message(jcr);
1310 dev->clear_append();
1313 dev->reserved_device++;
1314 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev);
1315 dcr->reserved_device = true;
1324 * We reserve the device for appending by incrementing the
1325 * reserved_device. We do virtually all the same work that
1326 * is done in acquire_device_for_append(), but we do
1327 * not attempt to mount the device. This routine allows
1328 * the DIR to reserve multiple devices before *really*
1329 * starting the job. It also permits the SD to refuse
1330 * certain devices (not up, ...).
1332 * Note, in reserving a device, if the device is for the
1333 * same pool and the same pool type, then it is acceptable.
1334 * The Media Type has already been checked. If we are
1335 * the first tor reserve the device, we put the pool
1336 * name and pool type in the device record.
1338 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1340 JCR *jcr = dcr->jcr;
1341 DEVICE *dev = dcr->dev;
1348 /* If device is being read, we cannot write it */
1349 if (dev->can_read()) {
1350 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1351 jcr->JobId, dev->print_name());
1352 Dmsg1(dbglvl, "%s", jcr->errmsg);
1353 queue_reserve_message(jcr);
1357 /* If device is unmounted, we are out of luck */
1358 if (is_device_unmounted(dev)) {
1359 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1360 jcr->JobId, dev->print_name());
1361 Dmsg1(dbglvl, "%s", jcr->errmsg);
1362 queue_reserve_message(jcr);
1366 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
1368 /* Now do detailed tests ... */
1369 if (can_reserve_drive(dcr, rctx) != 1) {
1370 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
1374 dev->reserved_device++;
1375 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device,
1376 dev->print_name(), dev);
1377 dcr->reserved_device = true;
1385 static int is_pool_ok(DCR *dcr)
1387 DEVICE *dev = dcr->dev;
1388 JCR *jcr = dcr->jcr;
1390 /* Now check if we want the same Pool and pool type */
1391 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1392 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1393 /* OK, compatible device */
1394 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1397 /* Drive Pool not suitable for us */
1398 Mmsg(jcr->errmsg, _(
1399 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1400 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1401 dev->reserved_device, dev->print_name());
1402 queue_reserve_message(jcr);
1403 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1404 dev->pool_name, dcr->pool_name);
1409 static bool is_max_jobs_ok(DCR *dcr)
1411 DEVICE *dev = dcr->dev;
1412 JCR *jcr = dcr->jcr;
1414 Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n",
1415 dcr->VolCatInfo.VolCatMaxJobs,
1416 dcr->VolCatInfo.VolCatJobs, dev->reserved_device,
1418 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1419 (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) {
1420 /* Max Job Vols depassed or already reserved */
1421 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1422 (uint32_t)jcr->JobId, dev->print_name());
1423 queue_reserve_message(jcr);
1424 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1425 return false; /* wait */
1431 * Returns: 1 if drive can be reserved
1432 * 0 if we should wait
1433 * -1 on error or impossibility
1435 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1437 DEVICE *dev = dcr->dev;
1438 JCR *jcr = dcr->jcr;
1440 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1441 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1442 rctx.autochanger_only, rctx.any_drive);
1444 /* Check for max jobs on this Volume */
1445 if (!is_max_jobs_ok(dcr)) {
1449 /* setting any_drive overrides PreferMountedVols flag */
1450 if (!rctx.any_drive) {
1452 * When PreferMountedVols is set, we keep track of the
1453 * drive in use that has the least number of writers, then if
1454 * no unmounted drive is found, we try that drive. This
1455 * helps spread the load to the least used drives.
1457 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1458 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
1459 dev->print_name(), rctx.low_use_drive->print_name());
1462 /* If he wants a free drive, but this one is busy, no go */
1463 if (!rctx.PreferMountedVols && dev->is_busy()) {
1464 /* Save least used drive */
1465 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1466 rctx.num_writers = dev->num_writers + dev->reserved_device;
1467 rctx.low_use_drive = dev;
1468 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
1469 dev->print_name(), rctx.num_writers);
1471 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->reserved_device);
1473 Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
1474 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1475 jcr->JobId, dev->print_name());
1476 queue_reserve_message(jcr);
1480 /* Check for prefer mounted volumes */
1481 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1482 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1483 jcr->JobId, dev->print_name());
1484 queue_reserve_message(jcr);
1485 Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
1486 return 0; /* No volume mounted */
1489 /* Check for exact Volume name match */
1490 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1493 if (rctx.exact_match && rctx.have_volume) {
1495 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1496 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1497 rctx.autochanger_only, rctx.any_drive);
1498 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1499 rctx.have_volume, dev->VolHdr.VolumeName,
1500 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1501 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1502 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1504 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1505 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1507 queue_reserve_message(jcr);
1508 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1509 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1512 if (is_volume_in_use(dcr)) {
1513 return 0; /* fail if volume on another drive */
1518 /* Check for unused autochanger drive */
1519 if (rctx.autochanger_only && !dev->is_busy() &&
1520 dev->VolHdr.VolumeName[0] == 0) {
1521 /* Device is available but not yet reserved, reserve it for us */
1522 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1523 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1524 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1525 return 1; /* reserve drive */
1529 * Handle the case that there are no writers
1531 if (dev->num_writers == 0) {
1532 /* Now check if there are any reservations on the drive */
1533 if (dev->reserved_device) {
1534 return is_pool_ok(dcr);
1535 } else if (dev->can_append()) {
1536 if (is_pool_ok(dcr)) {
1539 /* Changing pool, unload old tape if any in drive */
1540 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1541 unload_autochanger(dcr, 0);
1544 /* Device is available but not yet reserved, reserve it for us */
1545 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1546 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1547 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1548 return 1; /* reserve drive */
1552 * Check if the device is in append mode with writers (i.e.
1553 * available if pool is the same).
1555 if (dev->can_append() || dev->num_writers > 0) {
1556 return is_pool_ok(dcr);
1558 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1559 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1560 jcr->JobId, dev->print_name());
1561 queue_reserve_message(jcr);
1562 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1563 return -1; /* error, should not get here */
1565 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1566 jcr->JobId, dev->print_name());
1567 queue_reserve_message(jcr);
1568 Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1576 * Queue a reservation error or failure message for this jcr
1578 static void queue_reserve_message(JCR *jcr)
1586 msgs = jcr->reserve_msgs;
1591 * Look for duplicate message. If found, do
1594 for (i=msgs->size()-1; i >= 0; i--) {
1595 msg = (char *)msgs->get(i);
1599 /* Comparison based on 4 digit message number */
1600 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1604 /* Message unique, so insert it */
1605 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1612 * Send any reservation messages queued for this jcr
1614 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1621 msgs = jcr->reserve_msgs;
1622 if (!msgs || msgs->size() == 0) {
1625 for (i=msgs->size()-1; i >= 0; i--) {
1626 msg = (char *)msgs->get(i);
1628 sendit(" ", 3, arg);
1629 sendit(msg, strlen(msg), arg);
1640 * Pop and release any reservations messages
1642 static void pop_reserve_messages(JCR *jcr)
1648 msgs = jcr->reserve_msgs;
1652 while ((msg = (char *)msgs->pop())) {
1660 * Also called from acquire.c
1662 void release_reserve_messages(JCR *jcr)
1664 pop_reserve_messages(jcr);
1666 if (!jcr->reserve_msgs) {
1669 delete jcr->reserve_msgs;
1670 jcr->reserve_msgs = NULL;