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 #define jid() ((int)get_jobid_from_tid())
44 const int dbglvl = 50;
46 static dlist *vol_list = NULL;
47 static brwlock_t reservation_lock;
48 static brwlock_t vol_list_lock;
50 /* Forward referenced functions */
51 static int can_reserve_drive(DCR *dcr, RCTX &rctx);
52 static int reserve_device(RCTX &rctx);
53 static bool reserve_device_for_read(DCR *dcr);
54 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx);
55 static bool use_storage_cmd(JCR *jcr);
56 static void queue_reserve_message(JCR *jcr);
57 static void pop_reserve_messages(JCR *jcr);
58 //void switch_device(DCR *dcr, DEVICE *dev);
60 /* Requests from the Director daemon */
61 static char use_storage[] = "use storage=%127s media_type=%127s "
62 "pool_name=%127s pool_type=%127s append=%d copy=%d stripe=%d\n";
63 static char use_device[] = "use device=%127s\n";
65 /* Responses sent to Director daemon */
66 static char OK_device[] = "3000 OK use device device=%s\n";
67 static char NO_device[] = "3924 Device \"%s\" not in SD Device resources.\n";
68 static char BAD_use[] = "3913 Bad use command: %s\n";
70 bool use_cmd(JCR *jcr)
73 * Get the device, media, and pool information
75 if (!use_storage_cmd(jcr)) {
76 set_jcr_job_status(jcr, JS_ErrorTerminated);
77 memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
83 static int my_compare(void *item1, void *item2)
85 return strcmp(((VOLRES *)item1)->vol_name, ((VOLRES *)item2)->vol_name);
89 * This allows a given thread to recursively call lock_reservations.
90 * It must, of course, call unlock_... the same number of times.
92 void init_reservations_lock()
95 if ((errstat=rwl_init(&reservation_lock)) != 0) {
97 Emsg1(M_ABORT, 0, _("Unable to initialize reservation lock. ERR=%s\n"),
98 be.bstrerror(errstat));
101 if ((errstat=rwl_init(&vol_list_lock)) != 0) {
103 Emsg1(M_ABORT, 0, _("Unable to initialize volume list lock. ERR=%s\n"),
104 be.bstrerror(errstat));
108 void term_reservations_lock()
110 rwl_destroy(&reservation_lock);
111 rwl_destroy(&vol_list_lock);
114 int reservations_lock_count = 0;
116 /* This applies to a drive and to Volumes */
117 void _lock_reservations()
120 reservations_lock_count++;
121 if ((errstat=rwl_writelock(&reservation_lock)) != 0) {
123 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
124 errstat, be.bstrerror(errstat));
128 void _unlock_reservations()
131 reservations_lock_count--;
132 if ((errstat=rwl_writeunlock(&reservation_lock)) != 0) {
134 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
135 errstat, be.bstrerror(errstat));
139 int vol_list_lock_count = 0;
142 * This allows a given thread to recursively call to lock_volumes()
147 vol_list_lock_count++;
148 if ((errstat=rwl_writelock(&vol_list_lock)) != 0) {
150 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
151 errstat, be.bstrerror(errstat));
155 void _unlock_volumes()
158 vol_list_lock_count--;
159 if ((errstat=rwl_writeunlock(&vol_list_lock)) != 0) {
161 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
162 errstat, be.bstrerror(errstat));
168 * List Volumes -- this should be moved to status.c
175 static void debug_list_volumes(const char *imsg)
178 POOL_MEM msg(PM_MESSAGE);
181 foreach_dlist(vol, vol_list) {
183 Mmsg(msg, "List %s: %s in_use=%d on device %s\n", imsg,
184 vol->vol_name, vol->is_in_use(), vol->dev->print_name());
186 Mmsg(msg, "List %s: %s in_use=%d no dev\n", imsg, vol->vol_name,
189 Dmsg2(dbglvl, "jid=%u %s", jid(), msg.c_str());
194 foreach_dlist(vol, vol_list) {
195 if (vol->dev == dev) {
196 Dmsg0(dbglvl, "Two Volumes on same device.\n");
208 * List Volumes -- this should be moved to status.c
210 void list_volumes(void sendit(const char *msg, int len, void *sarg), void *arg)
213 POOL_MEM msg(PM_MESSAGE);
217 foreach_dlist(vol, vol_list) {
218 DEVICE *dev = vol->dev;
220 len = Mmsg(msg, "%s on device %s\n", vol->vol_name, dev->print_name());
221 sendit(msg.c_str(), len, arg);
222 len = Mmsg(msg, " Reader=%d writers=%d devres=%d volinuse=%d\n",
223 dev->can_read()?1:0, dev->num_writers, dev->num_reserved(),
225 sendit(msg.c_str(), len, arg);
227 len = Mmsg(msg, "%s no device. volinuse= %d\n", vol->vol_name,
229 sendit(msg.c_str(), len, arg);
236 * Create a Volume item to put in the Volume list
237 * Ensure that the device points to it.
239 static VOLRES *new_vol_item(DCR *dcr, const char *VolumeName)
242 vol = (VOLRES *)malloc(sizeof(VOLRES));
243 memset(vol, 0, sizeof(VOLRES));
244 vol->vol_name = bstrdup(VolumeName);
246 Dmsg4(dbglvl, "jid=%u new Vol=%s at %p dev=%s\n", (int)dcr->jcr->JobId,
247 VolumeName, vol->vol_name, vol->dev->print_name());
251 static void free_vol_item(VOLRES *vol)
266 * Put a new Volume entry in the Volume list. This
267 * effectively reserves the volume so that it will
268 * not be mounted again.
270 * If the device has any current volume associated with it,
271 * and it is a different Volume, and the device is not busy,
272 * we release the old Volume item and insert the new one.
274 * It is assumed that the device is free and locked so that
275 * we can change the device structure.
277 * Some details of the Volume list handling:
279 * 1. The Volume list entry must be attached to the drive (rather than
280 * attached to a job as it currently is. I.e. the drive that "owns"
281 * the volume (in use, mounted)
282 * must point to the volume (still to be maintained in a list).
284 * 2. The Volume is entered in the list when a drive is reserved.
286 * 3. When a drive is in use, the device code must appropriately update the
287 * volume name as it changes (currently the list is static -- an entry is
288 * removed when the Volume is no longer reserved, in use or mounted).
289 * The new code must keep the same list entry as long as the drive
290 * has any volume associated with it but the volume name in the list
291 * must be updated when the drive has a different volume mounted.
293 * 4. A job that has reserved a volume, can un-reserve the volume, and if the
294 * volume is not mounted, and not reserved, and not in use, it will be
295 * removed from the list.
297 * 5. If a job wants to reserve a drive with a different Volume from the one on
298 * the drive, it can re-use the drive for the new Volume.
300 * 6. If a job wants a Volume that is in a different drive, it can either use the
301 * other drive or take the volume, only if the other drive is not in use or
304 * One nice aspect of this is that the reserve use count and the writer use count
305 * already exist and are correctly programmed and will need no changes -- use
306 * counts are always very tricky.
308 * The old code had a concept of "reserving" a Volume, but was changed
309 * to reserving and using a drive. A volume is must be attached to (owned by) a
310 * drive and can move from drive to drive or be unused given certain specific
311 * conditions of the drive. The key is that the drive must "own" the Volume.
312 * The old code had the job (dcr) owning the volume (more or less). The job was
313 * to change the insertion and removal of the volumes from the list to be based
314 * on the drive rather than the job.
316 * Return: VOLRES entry on success
317 * NULL volume busy on another drive
319 VOLRES *reserve_volume(DCR *dcr, const char *VolumeName)
322 DEVICE * volatile dev = dcr->dev;
326 Dmsg3(dbglvl, "jid=%u enter reserve_volume=%s drive=%s\n", jid(), VolumeName,
327 dcr->dev->print_name());
329 * We lock the reservations system here to ensure
330 * when adding a new volume that no newly scheduled
331 * job can reserve it.
334 debug_list_volumes("begin reserve_volume");
336 * First, remove any old volume attached to this device as it
341 Dmsg5(dbglvl, "jid=%u Vol attached=%s, newvol=%s volinuse=%d on %s\n",
342 jid(), vol->vol_name, VolumeName, vol->is_in_use(), dev->print_name());
344 * Make sure we don't remove the current volume we are inserting
345 * because it was probably inserted by another job, or it
346 * is not being used and is marked as not reserved.
348 if (strcmp(vol->vol_name, VolumeName) == 0) {
349 Dmsg3(dbglvl, "jid=%u === set reserved vol=%s dev=%s\n", jid(), VolumeName,
350 vol->dev->print_name());
351 vol->set_in_use(); /* retake vol if released previously */
352 dcr->reserved_volume = true; /* reserved volume */
353 goto get_out; /* Volume already on this device */
355 /* Don't release a volume if it was reserved by someone other than us */
356 if (vol->is_in_use() && !dcr->reserved_volume) {
357 Dmsg2(dbglvl, "jid=%u Cannot free vol=%s. It is reserved.\n", jid(), vol->vol_name);
358 vol = NULL; /* vol in use */
361 Dmsg3(dbglvl, "jid=%u reserve_vol free vol=%s at %p\n", jid(), vol->vol_name, vol->vol_name);
363 dev->set_unload(); /* have to unload current volume */
364 debug_list_volumes("reserve_vol free");
368 /* Create a new Volume entry */
369 nvol = new_vol_item(dcr, VolumeName);
372 * Now try to insert the new Volume
374 vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
376 Dmsg3(dbglvl, "jid=%u Found vol=%s dev-same=%d\n", jid(), vol->vol_name, dev==vol->dev);
378 * At this point, a Volume with this name already is in the list,
379 * so we simply release our new Volume entry. Note, this should
380 * only happen if we are moving the volume from one drive to another.
382 Dmsg3(dbglvl, "jid=%u reserve_vol free-tmp vol=%s at %p\n",
383 (int)dcr->jcr->JobId, vol->vol_name, vol->vol_name);
385 * Clear dev pointer so that free_vol_item() doesn't
386 * take away our volume.
388 nvol->dev = NULL; /* don't zap dev entry */
391 /* Check if we are trying to use the Volume on a different drive */
392 if (dev != vol->dev) {
393 /* Caller wants to switch Volume to another device */
394 if (!vol->dev->is_busy() && !vol->is_swapping()) {
395 Dmsg4(dbglvl, "==== jid=%u Swap vol=%s from dev=%s to %s\n", jid(),
396 VolumeName, vol->dev->print_name(), dev->print_name());
397 free_volume(dev); /* free any volume attached to our drive */
398 vol->dev->set_unload(); /* unload our drive */
399 vol->set_swapping(); /* swap from other drive */
400 dev->swap_dev = vol->dev; /* remember to get this vol */
401 vol->dev->set_load(); /* then reload on our drive */
402 vol->dev->vol = NULL; /* remove volume from other drive */
403 vol->dev = dev; /* point it at our drive */
404 dev->vol = vol; /* point our drive at it */
405 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n",
406 VolumeName, vol->dev->print_name(), dev->print_name());
408 Dmsg4(dbglvl, "jid=%u ==== Swap not possible Vol busy vol=%s from dev=%s to %s\n", jid(),
409 VolumeName, vol->dev->print_name(), dev->print_name());
410 vol = NULL; /* device busy */
417 dev->vol = vol; /* point to newly inserted volume */
422 Dmsg3(dbglvl, "jid=%u === set in_use. vol=%s dev=%s\n", jid(), 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 Dmsg3(dbglvl, "jid=%u find_vol=%s found=%d\n", jid(), 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 Dmsg2(dbglvl, "jid=%u vol_unused: no vol on %s\n", (int)dcr->jcr->JobId, 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 Dmsg2(dbglvl, "jid=%u vol_unused: busy on %s\n", (int)dcr->jcr->JobId, 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 Dmsg5(dbglvl, "jid=%u === set not reserved vol=%s num_writers=%d dev_reserved=%d dev=%s\n",
568 jid(), 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 Dmsg2(dbglvl, "jid=%u No vol on dev %s\n", jid(), dev->print_name());
595 vol_list->remove(vol);
596 Dmsg3(dbglvl, "jid=%u === free_volume %s dev=%s\n", jid(), vol->vol_name, dev->print_name());
598 debug_list_volumes("free_volume");
604 /* Create the Volume list */
605 void create_volume_list()
608 if (vol_list == NULL) {
609 vol_list = New(dlist(vol, &vol->link));
613 /* Release all Volumes from the list */
614 void free_volume_list()
621 foreach_dlist(vol, vol_list) {
623 Dmsg3(dbglvl, "jid=%u free vol_list Volume=%s dev=%s\n", jid(),
624 vol->vol_name, vol->dev->print_name());
626 Dmsg3(dbglvl, "jid=%u free vol_list Volume=%s dev=%p\n", jid(),
627 vol->vol_name, vol->dev);
630 vol->vol_name = NULL;
637 bool DCR::can_i_use_volume()
643 vol = find_volume(VolumeName);
645 Dmsg2(dbglvl, "jid=%u Vol=%s not in use.\n", jid(), VolumeName);
646 goto get_out; /* vol not in list */
648 ASSERT(vol->dev != NULL);
650 if (dev == vol->dev) { /* same device OK */
651 Dmsg2(dbglvl, "jid=%u Vol=%s on same dev.\n", jid(), VolumeName);
654 Dmsg4(dbglvl, "jid=%u Vol=%s on %s we have %s\n", jid(), VolumeName,
655 vol->dev->print_name(), dev->print_name());
657 /* ***FIXME*** check this ... */
658 if (!vol->dev->is_busy()) {
659 Dmsg3(dbglvl, "jid=%u Vol=%s dev=%s not busy.\n", jid(), VolumeName, vol->dev->print_name());
662 Dmsg3(dbglvl, "jid=%u Vol=%s dev=%s busy.\n", jid(), VolumeName, vol->dev->print_name());
664 Dmsg3(dbglvl, "jid=%u Vol=%s in use by %s.\n", jid(), VolumeName, vol->dev->print_name());
675 * We get the following type of information:
677 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
681 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
685 static bool use_storage_cmd(JCR *jcr)
687 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
688 BSOCK *dir = jcr->dir_bsock;
696 memset(&rctx, 0, sizeof(RCTX));
699 * If there are multiple devices, the director sends us
700 * use_device for each device that it wants to use.
702 dirstore = New(alist(10, not_owned_by_alist));
703 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
705 Dmsg2(dbglvl, "jid=%u <dird: %s", jid(), dir->msg);
706 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
707 media_type.c_str(), pool_name.c_str(),
708 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
713 jcr->write_store = dirstore;
715 jcr->read_store = dirstore;
717 rctx.append = append;
718 unbash_spaces(store_name);
719 unbash_spaces(media_type);
720 unbash_spaces(pool_name);
721 unbash_spaces(pool_type);
722 store = new DIRSTORE;
723 dirstore->append(store);
724 memset(store, 0, sizeof(DIRSTORE));
725 store->device = New(alist(10));
726 bstrncpy(store->name, store_name, sizeof(store->name));
727 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
728 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
729 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
730 store->append = append;
732 /* Now get all devices */
733 while (dir->recv() >= 0) {
734 Dmsg2(dbglvl, "jid=%u <dird device: %s", jid(), dir->msg);
735 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
739 unbash_spaces(dev_name);
740 store->device->append(bstrdup(dev_name.c_str()));
742 } while (ok && dir->recv() >= 0);
744 /* Developer debug code */
746 if (debug_level >= dbglvl) {
747 foreach_alist(store, dirstore) {
748 Dmsg6(dbglvl, "jid=%u Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
749 (int)rctx.jcr->JobId,
750 store->name, store->media_type, store->pool_name,
751 store->pool_type, store->append);
752 foreach_alist(device_name, store->device) {
753 Dmsg2(dbglvl, "jid=%u Device=%s\n", jid(), 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 Dmsg1(dbglvl, "jid=%u repeat reserve algorithm\n", (int)rctx.jcr->JobId);
848 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
849 Dmsg1(dbglvl, "jid=%u Fail. !suitable_device || !wait_for_device\n",
850 (int)rctx.jcr->JobId);
854 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
856 unlock_reservations();
859 * If we get here, there are no suitable devices available, which
860 * means nothing configured. If a device is suitable but busy
861 * with another Volume, we will not come here.
863 unbash_spaces(dir->msg);
864 pm_strcpy(jcr->errmsg, dir->msg);
865 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
866 Jmsg(jcr, M_FATAL, 0, _("\n"
867 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
868 dev_name.c_str(), media_type.c_str());
869 dir->fsend(NO_device, dev_name.c_str());
871 Dmsg2(dbglvl, "jid=%u >dird: %s", jid(), dir->msg);
874 unbash_spaces(dir->msg);
875 pm_strcpy(jcr->errmsg, dir->msg);
876 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
877 dir->fsend(BAD_use, jcr->errmsg);
878 Dmsg2(dbglvl, "jid=%u >dird: %s", jid(), dir->msg);
881 release_reserve_messages(jcr);
887 * Walk through the autochanger resources and check if
888 * the volume is in one of them.
890 * Returns: true if volume is in device
893 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
895 AUTOCHANGER *changer = vol->dev->device->changer_res;
897 /* Find resource, and make sure we were able to open it */
898 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
899 Dmsg2(dbglvl, "jid=%u Found changer device %s\n", (int)rctx.jcr->JobId, vol->dev->device->hdr.name);
902 Dmsg2(dbglvl, "jid=%u Incorrect changer device %s\n", (int)rctx.jcr->JobId, changer->hdr.name);
907 * Search for a device suitable for this job.
908 * Note, this routine sets sets rctx.suitable_device if any
909 * device exists within the SD. The device may not be actually
911 * It also returns if it finds a useable device.
913 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
922 dirstore = jcr->write_store;
924 dirstore = jcr->read_store;
926 Dmsg5(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
927 (int)rctx.jcr->JobId,
928 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
929 rctx.autochanger_only);
932 * If the appropriate conditions of this if are met, namely that
933 * we are appending and the user wants mounted drive (or we
934 * force try a mounted drive because they are all busy), we
935 * start by looking at all the Volumes in the volume list.
937 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
938 dlist *temp_vol_list, *save_vol_list;
941 Dmsg0(dbglvl, "lock volumes\n");
944 * Create a temporary copy of the volume list. We do this,
945 * to avoid having the volume list locked during the
946 * call to reserve_device(), which would cause a deadlock.
947 * Note, we may want to add an update counter on the vol_list
948 * so that if it is modified while we are traversing the copy
949 * we can take note and act accordingly (probably redo the
950 * search at least a few times).
952 Dmsg1(dbglvl, "jid=%u duplicate vol list\n", (int)rctx.jcr->JobId);
953 temp_vol_list = New(dlist(vol, &vol->link));
954 foreach_dlist(vol, vol_list) {
956 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
957 memset(tvol, 0, sizeof(VOLRES));
958 tvol->vol_name = bstrdup(vol->vol_name);
959 tvol->dev = vol->dev;
960 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
962 tvol->dev = NULL; /* don't zap dev entry */
964 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
965 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
970 /* Look through reserved volumes for one we can use */
971 Dmsg1(dbglvl, "jid=%u look for vol in vol list\n", (int)rctx.jcr->JobId);
972 foreach_dlist(vol, temp_vol_list) {
974 Dmsg2(dbglvl, "jid=%u vol=%s no dev\n", (int)rctx.jcr->JobId, vol->vol_name);
977 /* Check with Director if this Volume is OK */
978 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
979 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
983 Dmsg2(dbglvl, "jid=%u vol=%s OK for this job\n", (int)rctx.jcr->JobId, vol->vol_name);
984 foreach_alist(store, dirstore) {
987 foreach_alist(device_name, store->device) {
988 /* Found a device, try to use it */
989 rctx.device_name = device_name;
990 rctx.device = vol->dev->device;
992 if (vol->dev->is_autochanger()) {
993 Dmsg2(dbglvl, "jid=%u vol=%s is in changer\n", (int)rctx.jcr->JobId,
995 if (!is_vol_in_autochanger(rctx, vol)) {
998 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
999 Dmsg3(dbglvl, "jid=%u device=%s not suitable want %s\n", (int)rctx.jcr->JobId,
1000 vol->dev->device->hdr.name, device_name);
1004 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
1005 rctx.have_volume = true;
1006 /* Try reserving this device and volume */
1007 Dmsg3(dbglvl, "jid=%u try vol=%s on device=%s\n", (int)rctx.jcr->JobId,
1008 rctx.VolumeName, device_name);
1009 stat = reserve_device(rctx);
1010 if (stat == 1) { /* found available device */
1011 Dmsg2(dbglvl, "jid=%u Suitable device found=%s\n", (int)rctx.jcr->JobId,
1015 } else if (stat == 0) { /* device busy */
1016 Dmsg2(dbglvl, "jid=%u Suitable device=%s, busy: not use\n",
1017 (int)rctx.jcr->JobId, device_name);
1019 /* otherwise error */
1020 Dmsg1(dbglvl, "jid=%u No suitable device found.\n", (int)rctx.jcr->JobId);
1022 rctx.have_volume = false;
1023 rctx.VolumeName[0] = 0;
1032 } /* end for loop over reserved volumes */
1034 Dmsg1(dbglvl, "%u lock volumes\n", jid());
1036 save_vol_list = vol_list;
1037 vol_list = temp_vol_list;
1038 free_volume_list(); /* release temp_vol_list */
1039 vol_list = save_vol_list;
1040 Dmsg1(dbglvl, "jid=%u deleted temp vol list\n", (int)rctx.jcr->JobId);
1041 Dmsg1(dbglvl, "jid=%u unlock volumes\n", (int)rctx.jcr->JobId);
1045 Dmsg2(dbglvl, "jid=%u got vol %s from in-use vols list\n", (int)rctx.jcr->JobId,
1051 * No reserved volume we can use, so now search for an available device.
1053 * For each storage device that the user specified, we
1054 * search and see if there is a resource for that device.
1056 foreach_alist(store, dirstore) {
1058 foreach_alist(device_name, store->device) {
1060 rctx.device_name = device_name;
1061 stat = search_res_for_device(rctx);
1062 if (stat == 1) { /* found available device */
1063 Dmsg2(dbglvl, "jid=%u available device found=%s\n", (int)rctx.jcr->JobId,device_name);
1066 } else if (stat == 0) { /* device busy */
1067 Dmsg2(dbglvl, "jid=%u No usable device=%s, busy: not use\n", (int)rctx.jcr->JobId,device_name);
1069 /* otherwise error */
1070 Dmsg1(dbglvl, "jid=%u No usable device found.\n", (int)rctx.jcr->JobId);
1078 Dmsg1(dbglvl, "OK dev found. Vol=%s\n", rctx.VolumeName);
1080 Dmsg0(dbglvl, "Leave find_suit_dev: no dev found.\n");
1086 * Search for a particular storage device with particular storage
1087 * characteristics (MediaType).
1089 int search_res_for_device(RCTX &rctx)
1091 AUTOCHANGER *changer;
1094 Dmsg2(dbglvl, "jid=%u search res for %s\n", (int)rctx.jcr->JobId, rctx.device_name);
1095 /* Look through Autochangers first */
1096 foreach_res(changer, R_AUTOCHANGER) {
1097 Dmsg2(dbglvl, "jid=%u Try match changer res=%s\n", (int)rctx.jcr->JobId, changer->hdr.name);
1098 /* Find resource, and make sure we were able to open it */
1099 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1100 /* Try each device in this AutoChanger */
1101 foreach_alist(rctx.device, changer->device) {
1102 Dmsg2(dbglvl, "jid=%u Try changer device %s\n", (int)rctx.jcr->JobId,
1103 rctx.device->hdr.name);
1104 stat = reserve_device(rctx);
1105 if (stat != 1) { /* try another device */
1109 if (rctx.store->append == SD_APPEND) {
1110 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for append.\n",
1111 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1112 rctx.jcr->dcr->dev->num_reserved());
1114 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for read.\n",
1115 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1116 rctx.jcr->read_dcr->dev->num_reserved());
1123 /* Now if requested look through regular devices */
1124 if (!rctx.autochanger_only) {
1125 foreach_res(rctx.device, R_DEVICE) {
1126 Dmsg2(dbglvl, "jid=%u Try match res=%s\n", (int)rctx.jcr->JobId, rctx.device->hdr.name);
1127 /* Find resource, and make sure we were able to open it */
1128 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1129 stat = reserve_device(rctx);
1130 if (stat != 1) { /* try another device */
1134 if (rctx.store->append == SD_APPEND) {
1135 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for append.\n",
1136 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1137 rctx.jcr->dcr->dev->num_reserved());
1139 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for read.\n",
1140 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1141 rctx.jcr->read_dcr->dev->num_reserved());
1147 return -1; /* nothing found */
1151 * Try to reserve a specific device.
1153 * Returns: 1 -- OK, have DCR
1157 static int reserve_device(RCTX &rctx)
1161 const int name_len = MAX_NAME_LENGTH;
1163 /* Make sure MediaType is OK */
1164 Dmsg3(dbglvl, "jid=%u chk MediaType device=%s request=%s\n",
1165 (int)rctx.jcr->JobId,
1166 rctx.device->media_type, rctx.store->media_type);
1167 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1171 /* Make sure device exists -- i.e. we can stat() it */
1172 if (!rctx.device->dev) {
1173 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1175 if (!rctx.device->dev) {
1176 if (rctx.device->changer_res) {
1177 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1178 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1179 rctx.device->hdr.name, rctx.device_name);
1181 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1182 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1185 return -1; /* no use waiting */
1188 rctx.suitable_device = true;
1189 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1190 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1192 BSOCK *dir = rctx.jcr->dir_bsock;
1193 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1194 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1197 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1198 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1199 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1200 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1201 if (rctx.store->append == SD_APPEND) {
1202 Dmsg3(dbglvl, "jid=%u have_vol=%d vol=%s\n", (int)rctx.jcr->JobId,
1203 rctx.have_volume, rctx.VolumeName);
1204 ok = reserve_device_for_append(dcr, rctx);
1209 rctx.jcr->dcr = dcr;
1210 Dmsg6(dbglvl, "jid=%u Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1211 (int)rctx.jcr->JobId,
1212 dcr->dev->num_reserved(),
1213 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1214 if (rctx.have_volume) {
1215 if (reserve_volume(dcr, rctx.VolumeName)) {
1216 Dmsg2(dbglvl, "jid=%u Reserved vol=%s\n", jid(), rctx.VolumeName);
1218 Dmsg2(dbglvl, "jid=%u Could not reserve vol=%s\n", jid(), rctx.VolumeName);
1222 dcr->any_volume = true;
1223 if (dir_find_next_appendable_volume(dcr)) {
1224 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1225 Dmsg2(dbglvl, "jid=%u looking for Volume=%s\n", (int)rctx.jcr->JobId, rctx.VolumeName);
1226 rctx.have_volume = true;
1228 Dmsg1(dbglvl, "jid=%u No next volume found\n", (int)rctx.jcr->JobId);
1229 rctx.have_volume = false;
1230 rctx.VolumeName[0] = 0;
1232 * If there is at least one volume that is valid and in use,
1233 * but we get here, check if we are running with prefers
1234 * non-mounted drives. In that case, we have selected a
1235 * non-used drive and our one and only volume is mounted
1236 * elsewhere, so we bail out and retry using that drive.
1238 if (dcr->found_in_use() && !rctx.PreferMountedVols) {
1239 rctx.PreferMountedVols = true;
1240 if (dcr->VolumeName[0]) {
1241 dcr->unreserve_device();
1246 * Note. Under some circumstances, the Director can hand us
1247 * a Volume name that is not the same as the one on the current
1248 * drive, and in that case, the call above to find the next
1249 * volume will fail because in attempting to reserve the Volume
1250 * the code will realize that we already have a tape mounted,
1251 * and it will fail. This *should* only happen if there are
1252 * writers, thus the following test. In that case, we simply
1253 * bail out, and continue waiting, rather than plunging on
1254 * and hoping that the operator can resolve the problem.
1256 if (dcr->dev->num_writers != 0) {
1257 if (dcr->VolumeName[0]) {
1258 dcr->unreserve_device();
1265 ok = reserve_device_for_read(dcr);
1267 rctx.jcr->read_dcr = dcr;
1268 Dmsg6(dbglvl, "jid=%u Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1269 (int)rctx.jcr->JobId,
1270 dcr->dev->num_reserved(),
1271 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1278 if (rctx.notify_dir) {
1280 BSOCK *dir = rctx.jcr->dir_bsock;
1281 pm_strcpy(dev_name, rctx.device->hdr.name);
1282 bash_spaces(dev_name);
1283 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1284 Dmsg2(dbglvl, "jid=%u >dird changer: %s", jid(), dir->msg);
1291 rctx.have_volume = false;
1292 Dmsg1(dbglvl, "jid=%u Not OK.\n", (int)rctx.jcr->JobId);
1293 rctx.VolumeName[0] = 0;
1298 * We "reserve" the drive by setting the ST_READ bit. No one else
1299 * should touch the drive until that is cleared.
1300 * This allows the DIR to "reserve" the device before actually
1303 static bool reserve_device_for_read(DCR *dcr)
1305 DEVICE *dev = dcr->dev;
1306 JCR *jcr = dcr->jcr;
1313 if (is_device_unmounted(dev)) {
1314 Dmsg2(dbglvl, "jid=%u Device %s is BLOCKED due to user unmount.\n",
1315 (int)jcr->JobId, dev->print_name());
1316 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1317 jcr->JobId, dev->print_name());
1318 queue_reserve_message(jcr);
1322 if (dev->is_busy()) {
1323 Dmsg5(dbglvl, "jid=%u Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1324 (int)jcr->JobId, dev->print_name(),
1325 dev->state & ST_READ?1:0, dev->num_writers, dev->num_reserved());
1326 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1327 jcr->JobId, dev->print_name());
1328 queue_reserve_message(jcr);
1332 dev->clear_append();
1335 dcr->set_reserved();
1344 * We reserve the device for appending by incrementing the
1345 * num_reserved(). We do virtually all the same work that
1346 * is done in acquire_device_for_append(), but we do
1347 * not attempt to mount the device. This routine allows
1348 * the DIR to reserve multiple devices before *really*
1349 * starting the job. It also permits the SD to refuse
1350 * certain devices (not up, ...).
1352 * Note, in reserving a device, if the device is for the
1353 * same pool and the same pool type, then it is acceptable.
1354 * The Media Type has already been checked. If we are
1355 * the first tor reserve the device, we put the pool
1356 * name and pool type in the device record.
1358 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1360 JCR *jcr = dcr->jcr;
1361 DEVICE *dev = dcr->dev;
1368 /* If device is being read, we cannot write it */
1369 if (dev->can_read()) {
1370 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1371 jcr->JobId, dev->print_name());
1372 Dmsg2(dbglvl, "jid=%u %s", jid(), jcr->errmsg);
1373 queue_reserve_message(jcr);
1377 /* If device is unmounted, we are out of luck */
1378 if (is_device_unmounted(dev)) {
1379 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1380 jcr->JobId, dev->print_name());
1381 Dmsg2(dbglvl, "jid=%u %s", jid(), jcr->errmsg);
1382 queue_reserve_message(jcr);
1386 Dmsg2(dbglvl, "jid=%u reserve_append device is %s\n", jid(), dev->print_name());
1388 /* Now do detailed tests ... */
1389 if (can_reserve_drive(dcr, rctx) != 1) {
1390 Dmsg1(dbglvl, "jid=%u can_reserve_drive!=1\n", (int)jcr->JobId);
1394 dcr->set_reserved();
1402 static int is_pool_ok(DCR *dcr)
1404 DEVICE *dev = dcr->dev;
1405 JCR *jcr = dcr->jcr;
1407 /* Now check if we want the same Pool and pool type */
1408 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1409 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1410 /* OK, compatible device */
1411 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1414 /* Drive Pool not suitable for us */
1415 Mmsg(jcr->errmsg, _(
1416 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1417 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1418 dev->num_reserved(), dev->print_name());
1419 queue_reserve_message(jcr);
1420 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1421 dev->pool_name, dcr->pool_name);
1426 static bool is_max_jobs_ok(DCR *dcr)
1428 DEVICE *dev = dcr->dev;
1429 JCR *jcr = dcr->jcr;
1431 Dmsg5(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Status=%s Vol=%s\n",
1432 dcr->VolCatInfo.VolCatMaxJobs,
1433 dcr->VolCatInfo.VolCatJobs, dev->num_reserved(),
1434 dcr->VolCatInfo.VolCatStatus,
1436 if (strcmp(dcr->VolCatInfo.VolCatStatus, "Recycle") == 0) {
1439 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1440 (dcr->VolCatInfo.VolCatJobs + dev->num_reserved())) {
1441 /* Max Job Vols depassed or already reserved */
1442 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1443 (uint32_t)jcr->JobId, dev->print_name());
1444 queue_reserve_message(jcr);
1445 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1446 return false; /* wait */
1452 * Returns: 1 if drive can be reserved
1453 * 0 if we should wait
1454 * -1 on error or impossibility
1456 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1458 DEVICE *dev = dcr->dev;
1459 JCR *jcr = dcr->jcr;
1461 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1463 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1464 rctx.autochanger_only, rctx.any_drive);
1466 /* Check for max jobs on this Volume */
1467 if (!is_max_jobs_ok(dcr)) {
1471 /* setting any_drive overrides PreferMountedVols flag */
1472 if (!rctx.any_drive) {
1474 * When PreferMountedVols is set, we keep track of the
1475 * drive in use that has the least number of writers, then if
1476 * no unmounted drive is found, we try that drive. This
1477 * helps spread the load to the least used drives.
1479 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1480 Dmsg3(dbglvl, "jid=%u OK dev=%s == low_drive=%s.\n",
1481 jcr->JobId, dev->print_name(), rctx.low_use_drive->print_name());
1484 /* If he wants a free drive, but this one is busy, no go */
1485 if (!rctx.PreferMountedVols && dev->is_busy()) {
1486 /* Save least used drive */
1487 if ((dev->num_writers + dev->num_reserved()) < rctx.num_writers) {
1488 rctx.num_writers = dev->num_writers + dev->num_reserved();
1489 rctx.low_use_drive = dev;
1490 Dmsg3(dbglvl, "jid=%u set low use drive=%s num_writers=%d\n",
1491 (int)jcr->JobId, dev->print_name(), rctx.num_writers);
1493 Dmsg2(dbglvl, "jid=%u not low use num_writers=%d\n",
1494 (int)jcr->JobId, dev->num_writers+dev->num_reserved());
1496 Dmsg1(dbglvl, "jid=%u failed: !prefMnt && busy.\n", jcr->JobId);
1497 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1498 jcr->JobId, dev->print_name());
1499 queue_reserve_message(jcr);
1503 /* Check for prefer mounted volumes */
1504 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1505 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1506 jcr->JobId, dev->print_name());
1507 queue_reserve_message(jcr);
1508 Dmsg1(dbglvl, "jid=%u failed: want mounted -- no vol\n", (uint32_t)jcr->JobId);
1509 return 0; /* No volume mounted */
1512 /* Check for exact Volume name match */
1513 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1516 if (rctx.exact_match && rctx.have_volume) {
1518 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1520 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1521 rctx.autochanger_only, rctx.any_drive);
1522 Dmsg5(dbglvl, "jid=%u have_vol=%d have=%s resvol=%s want=%s\n",
1523 (int)jcr->JobId, rctx.have_volume, dev->VolHdr.VolumeName,
1524 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1525 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1526 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1528 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1529 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1531 queue_reserve_message(jcr);
1532 Dmsg4(dbglvl, "jid=%u not OK: dev have=%s resvol=%s want=%s\n", (int)jcr->JobId,
1533 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1536 if (!dcr->can_i_use_volume()) {
1537 return 0; /* fail if volume on another drive */
1542 /* Check for unused autochanger drive */
1543 if (rctx.autochanger_only && !dev->is_busy() &&
1544 dev->VolHdr.VolumeName[0] == 0) {
1545 /* Device is available but not yet reserved, reserve it for us */
1546 Dmsg2(dbglvl, "jid=%u OK Res Unused autochanger %s.\n",
1547 jcr->JobId, dev->print_name());
1548 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1549 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1550 return 1; /* reserve drive */
1554 * Handle the case that there are no writers
1556 if (dev->num_writers == 0) {
1557 /* Now check if there are any reservations on the drive */
1558 if (dev->num_reserved()) {
1559 return is_pool_ok(dcr);
1560 } else if (dev->can_append()) {
1561 if (is_pool_ok(dcr)) {
1564 /* Changing pool, unload old tape if any in drive */
1565 Dmsg1(dbglvl, "jid=%u OK dev: num_writers=0, not reserved, pool change, unload changer\n", (int)jcr->JobId);
1566 /* ***FIXME*** use set_unload() */
1567 unload_autochanger(dcr, 0);
1570 /* Device is available but not yet reserved, reserve it for us */
1571 Dmsg2(dbglvl, "jid=%u OK Dev avail reserved %s\n", (int)jcr->JobId, dev->print_name());
1572 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1573 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1574 return 1; /* reserve drive */
1578 * Check if the device is in append mode with writers (i.e.
1579 * available if pool is the same).
1581 if (dev->can_append() || dev->num_writers > 0) {
1582 return is_pool_ok(dcr);
1584 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1585 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1586 jcr->JobId, dev->print_name());
1587 queue_reserve_message(jcr);
1588 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1589 return -1; /* error, should not get here */
1591 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1592 jcr->JobId, dev->print_name());
1593 queue_reserve_message(jcr);
1594 Dmsg2(dbglvl, "jid=%u failed: No reserve %s\n", jcr->JobId, dev->print_name());
1602 * Queue a reservation error or failure message for this jcr
1604 static void queue_reserve_message(JCR *jcr)
1612 msgs = jcr->reserve_msgs;
1617 * Look for duplicate message. If found, do
1620 for (i=msgs->size()-1; i >= 0; i--) {
1621 msg = (char *)msgs->get(i);
1625 /* Comparison based on 4 digit message number */
1626 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1630 /* Message unique, so insert it */
1631 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1638 * Send any reservation messages queued for this jcr
1640 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1647 msgs = jcr->reserve_msgs;
1648 if (!msgs || msgs->size() == 0) {
1651 for (i=msgs->size()-1; i >= 0; i--) {
1652 msg = (char *)msgs->get(i);
1654 sendit(" ", 3, arg);
1655 sendit(msg, strlen(msg), arg);
1666 * Pop and release any reservations messages
1668 static void pop_reserve_messages(JCR *jcr)
1674 msgs = jcr->reserve_msgs;
1678 while ((msg = (char *)msgs->pop())) {
1686 * Also called from acquire.c
1688 void release_reserve_messages(JCR *jcr)
1690 pop_reserve_messages(jcr);
1692 if (!jcr->reserve_msgs) {
1695 delete jcr->reserve_msgs;
1696 jcr->reserve_msgs = NULL;