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 */
392 * Check if we are trying to use the Volume on a different drive
394 * vol->dev is where the Volume we want is
396 if (dev != vol->dev) {
397 /* Caller wants to switch Volume to another device */
398 if (!vol->dev->is_busy() && !vol->is_swapping()) {
399 Dmsg4(dbglvl, "==== jid=%u Swap vol=%s from dev=%s to %s\n", jid(),
400 VolumeName, vol->dev->print_name(), dev->print_name());
401 free_volume(dev); /* free any volume attached to our drive */
402 vol->dev->set_unload(); /* unload the other drive */
403 vol->set_swapping(); /* swap from other drive */
404 dev->swap_dev = vol->dev; /* remember to get this vol */
405 vol->dev->set_load(); /* then reload on our drive */
406 vol->dev->vol = NULL; /* remove volume from other drive */
407 vol->dev = dev; /* point the Volume at our drive */
408 dev->vol = vol; /* point our drive at the Volume */
410 Dmsg4(dbglvl, "jid=%u ==== Swap not possible Vol busy vol=%s from dev=%s to %s\n", jid(),
411 VolumeName, vol->dev->print_name(), dev->print_name());
412 vol = NULL; /* device busy */
419 dev->vol = vol; /* point to newly inserted volume */
424 Dmsg3(dbglvl, "jid=%u === set in_use. vol=%s dev=%s\n", jid(), vol->vol_name,
425 vol->dev->print_name());
427 dcr->reserved_volume = true;
429 debug_list_volumes("end new volume");
435 * Switch from current device to given device
439 void switch_device(DCR *dcr, DEVICE *dev)
444 memcpy(&save_dcr, dcr, sizeof(save_dcr));
445 clean_device(dcr); /* clean up the dcr */
447 dcr->dev = dev; /* get new device pointer */
448 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
449 dcr->dev->print_name());
451 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
452 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
453 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
454 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
455 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
456 bstrncpy(dcr->dev_name, dev->dev_name, sizeof(dcr->dev_name));
458 // dcr->set_reserved();
465 * Search for a Volume name in the Volume list.
467 * Returns: VOLRES entry on success
468 * NULL if the Volume is not in the list
470 VOLRES *find_volume(const char *VolumeName)
473 /* Do not lock reservations here */
475 vol.vol_name = bstrdup(VolumeName);
476 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
478 Dmsg3(dbglvl, "jid=%u find_vol=%s found=%d\n", jid(), VolumeName, fvol!=NULL);
479 debug_list_volumes("find_volume");
484 void DCR::set_reserved()
487 Dmsg2(dbglvl, "Inc reserve=%d dev=%s\n", dev->num_reserved(), dev->print_name());
491 void DCR::clear_reserved()
496 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->num_reserved(), dev->print_name());
501 * Remove any reservation from a drive and tell the system
502 * that the volume is unused at least by us.
504 void DCR::unreserve_device()
509 reserved_volume = false;
510 /* If we set read mode in reserving, remove it */
511 if (dev->can_read()) {
514 if (dev->num_writers < 0) {
515 Jmsg1(jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
516 dev->num_writers = 0;
518 if (dev->num_reserved() == 0 && dev->num_writers == 0) {
526 * Free a Volume from the Volume list if it is no longer used
527 * Note, for tape drives we want to remember where the Volume
528 * was when last used, so rather than free the volume entry,
529 * we simply mark it "not reserved" so when the drive is really
530 * needed for another volume, we can reuse it.
532 * Returns: true if the Volume found and "removed" from the list
533 * false if the Volume is not in the list or is in use
535 bool volume_unused(DCR *dcr)
537 DEVICE *dev = dcr->dev;
540 Dmsg2(dbglvl, "jid=%u vol_unused: no vol on %s\n", (int)dcr->jcr->JobId, dev->print_name());
541 debug_list_volumes("null vol cannot unreserve_volume");
544 if (dev->vol->is_swapping()) {
545 Dmsg1(dbglvl, "vol_unused: vol being swapped on %s\n", dev->print_name());
546 debug_list_volumes("swapping vol cannot unreserve_volume");
551 if (dev->is_busy()) {
552 Dmsg2(dbglvl, "jid=%u vol_unused: busy on %s\n", (int)dcr->jcr->JobId, dev->print_name());
553 debug_list_volumes("dev busy cannot unreserve_volume");
558 if (dev->num_writers > 0 || dev->num_reserved() > 0) {
564 * If this is a tape, we do not free the volume, rather we wait
565 * until the autoloader unloads it, or until another tape is
566 * explicitly read in this drive. This allows the SD to remember
567 * where the tapes are or last were.
569 Dmsg5(dbglvl, "jid=%u === set not reserved vol=%s num_writers=%d dev_reserved=%d dev=%s\n",
570 jid(), dev->vol->vol_name, dev->num_writers, dev->num_reserved(), dev->print_name());
571 dev->vol->clear_in_use();
572 if (dev->is_tape() || dev->is_autochanger()) {
576 * Note, this frees the volume reservation entry, but the
577 * file descriptor remains open with the OS.
579 return free_volume(dev);
584 * Unconditionally release the volume entry
586 bool free_volume(DEVICE *dev)
590 if (dev->vol == NULL) {
591 Dmsg2(dbglvl, "jid=%u No vol on dev %s\n", jid(), dev->print_name());
596 /* Don't free a volume while it is being swapped */
597 if (!vol->is_swapping()) {
599 vol_list->remove(vol);
600 Dmsg3(dbglvl, "jid=%u === free_volume %s dev=%s\n", jid(), vol->vol_name, dev->print_name());
602 debug_list_volumes("free_volume");
609 /* Create the Volume list */
610 void create_volume_list()
613 if (vol_list == NULL) {
614 vol_list = New(dlist(vol, &vol->link));
618 /* Release all Volumes from the list */
619 void free_volume_list()
626 foreach_dlist(vol, vol_list) {
628 Dmsg3(dbglvl, "jid=%u free vol_list Volume=%s dev=%s\n", jid(),
629 vol->vol_name, vol->dev->print_name());
631 Dmsg3(dbglvl, "jid=%u free vol_list Volume=%s dev=%p\n", jid(),
632 vol->vol_name, vol->dev);
635 vol->vol_name = NULL;
642 bool DCR::can_i_use_volume()
648 vol = find_volume(VolumeName);
650 Dmsg2(dbglvl, "jid=%u Vol=%s not in use.\n", jid(), VolumeName);
651 goto get_out; /* vol not in list */
653 ASSERT(vol->dev != NULL);
655 if (dev == vol->dev) { /* same device OK */
656 Dmsg2(dbglvl, "jid=%u Vol=%s on same dev.\n", jid(), VolumeName);
659 Dmsg4(dbglvl, "jid=%u Vol=%s on %s we have %s\n", jid(), VolumeName,
660 vol->dev->print_name(), dev->print_name());
662 /* ***FIXME*** check this ... */
663 if (!vol->dev->is_busy()) {
664 Dmsg3(dbglvl, "jid=%u Vol=%s dev=%s not busy.\n", jid(), VolumeName, vol->dev->print_name());
667 Dmsg3(dbglvl, "jid=%u Vol=%s dev=%s busy.\n", jid(), VolumeName, vol->dev->print_name());
669 Dmsg3(dbglvl, "jid=%u Vol=%s in use by %s.\n", jid(), VolumeName, vol->dev->print_name());
680 * We get the following type of information:
682 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
686 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
690 static bool use_storage_cmd(JCR *jcr)
692 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
693 BSOCK *dir = jcr->dir_bsock;
701 memset(&rctx, 0, sizeof(RCTX));
704 * If there are multiple devices, the director sends us
705 * use_device for each device that it wants to use.
707 dirstore = New(alist(10, not_owned_by_alist));
708 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
710 Dmsg2(dbglvl, "jid=%u <dird: %s", jid(), dir->msg);
711 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
712 media_type.c_str(), pool_name.c_str(),
713 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
718 jcr->write_store = dirstore;
720 jcr->read_store = dirstore;
722 rctx.append = append;
723 unbash_spaces(store_name);
724 unbash_spaces(media_type);
725 unbash_spaces(pool_name);
726 unbash_spaces(pool_type);
727 store = new DIRSTORE;
728 dirstore->append(store);
729 memset(store, 0, sizeof(DIRSTORE));
730 store->device = New(alist(10));
731 bstrncpy(store->name, store_name, sizeof(store->name));
732 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
733 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
734 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
735 store->append = append;
737 /* Now get all devices */
738 while (dir->recv() >= 0) {
739 Dmsg2(dbglvl, "jid=%u <dird device: %s", jid(), dir->msg);
740 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
744 unbash_spaces(dev_name);
745 store->device->append(bstrdup(dev_name.c_str()));
747 } while (ok && dir->recv() >= 0);
749 /* Developer debug code */
751 if (debug_level >= dbglvl) {
752 foreach_alist(store, dirstore) {
753 Dmsg6(dbglvl, "jid=%u Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
754 (int)rctx.jcr->JobId,
755 store->name, store->media_type, store->pool_name,
756 store->pool_type, store->append);
757 foreach_alist(device_name, store->device) {
758 Dmsg2(dbglvl, "jid=%u Device=%s\n", jid(), device_name);
763 init_jcr_device_wait_timers(jcr);
764 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
766 BSOCK *dir = jcr->dir_bsock;
767 dir->fsend(_("3939 Could not get dcr\n"));
768 Dmsg1(dbglvl, ">dird: %s", dir->msg);
772 * At this point, we have a list of all the Director's Storage
773 * resources indicated for this Job, which include Pool, PoolType,
774 * storage name, and Media type.
775 * Then for each of the Storage resources, we have a list of
776 * device names that were given.
778 * Wiffle through them and find one that can do the backup.
781 int wait_for_device_retries = 0;
784 rctx.notify_dir = true;
787 for ( ; !fail && !job_canceled(jcr); ) {
788 pop_reserve_messages(jcr);
789 rctx.suitable_device = false;
790 rctx.have_volume = false;
791 rctx.VolumeName[0] = 0;
792 rctx.any_drive = false;
793 if (!jcr->PreferMountedVols) {
795 * Here we try to find a drive that is not used.
796 * This will maximize the use of available drives.
799 rctx.num_writers = 20000000; /* start with impossible number */
800 rctx.low_use_drive = NULL;
801 rctx.PreferMountedVols = false;
802 rctx.exact_match = false;
803 rctx.autochanger_only = true;
804 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
807 /* Look through all drives possibly for low_use drive */
808 if (rctx.low_use_drive) {
809 rctx.try_low_use_drive = true;
810 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
813 rctx.try_low_use_drive = false;
815 rctx.autochanger_only = false;
816 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
821 * Now we look for a drive that may or may not be in
824 /* Look for an exact Volume match all drives */
825 rctx.PreferMountedVols = true;
826 rctx.exact_match = true;
827 rctx.autochanger_only = false;
828 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
831 /* Look for any mounted drive */
832 rctx.exact_match = false;
833 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
837 rctx.any_drive = true;
838 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
841 /* Keep reservations locked *except* during wait_for_device() */
842 unlock_reservations();
844 * The idea of looping on repeat a few times it to ensure
845 * that if there is some subtle timing problem between two
846 * jobs, we will simply try again, and most likely succeed.
847 * This can happen if one job reserves a drive or finishes using
848 * a drive at the same time a second job wants it.
850 if (repeat++ > 1) { /* try algorithm 3 times */
851 bmicrosleep(30, 0); /* wait a bit */
852 Dmsg1(dbglvl, "jid=%u repeat reserve algorithm\n", (int)rctx.jcr->JobId);
853 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
854 Dmsg1(dbglvl, "jid=%u Fail. !suitable_device || !wait_for_device\n",
855 (int)rctx.jcr->JobId);
859 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
861 unlock_reservations();
864 * If we get here, there are no suitable devices available, which
865 * means nothing configured. If a device is suitable but busy
866 * with another Volume, we will not come here.
868 unbash_spaces(dir->msg);
869 pm_strcpy(jcr->errmsg, dir->msg);
870 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
871 Jmsg(jcr, M_FATAL, 0, _("\n"
872 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
873 dev_name.c_str(), media_type.c_str());
874 dir->fsend(NO_device, dev_name.c_str());
876 Dmsg2(dbglvl, "jid=%u >dird: %s", jid(), dir->msg);
879 unbash_spaces(dir->msg);
880 pm_strcpy(jcr->errmsg, dir->msg);
881 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
882 dir->fsend(BAD_use, jcr->errmsg);
883 Dmsg2(dbglvl, "jid=%u >dird: %s", jid(), dir->msg);
886 release_reserve_messages(jcr);
892 * Walk through the autochanger resources and check if
893 * the volume is in one of them.
895 * Returns: true if volume is in device
898 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
900 AUTOCHANGER *changer = vol->dev->device->changer_res;
902 /* Find resource, and make sure we were able to open it */
903 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
904 Dmsg2(dbglvl, "jid=%u Found changer device %s\n", (int)rctx.jcr->JobId, vol->dev->device->hdr.name);
907 Dmsg2(dbglvl, "jid=%u Incorrect changer device %s\n", (int)rctx.jcr->JobId, changer->hdr.name);
912 * Search for a device suitable for this job.
913 * Note, this routine sets sets rctx.suitable_device if any
914 * device exists within the SD. The device may not be actually
916 * It also returns if it finds a useable device.
918 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
927 dirstore = jcr->write_store;
929 dirstore = jcr->read_store;
931 Dmsg5(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
932 (int)rctx.jcr->JobId,
933 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
934 rctx.autochanger_only);
937 * If the appropriate conditions of this if are met, namely that
938 * we are appending and the user wants mounted drive (or we
939 * force try a mounted drive because they are all busy), we
940 * start by looking at all the Volumes in the volume list.
942 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
943 dlist *temp_vol_list, *save_vol_list;
946 Dmsg0(dbglvl, "lock volumes\n");
949 * Create a temporary copy of the volume list. We do this,
950 * to avoid having the volume list locked during the
951 * call to reserve_device(), which would cause a deadlock.
952 * Note, we may want to add an update counter on the vol_list
953 * so that if it is modified while we are traversing the copy
954 * we can take note and act accordingly (probably redo the
955 * search at least a few times).
957 Dmsg1(dbglvl, "jid=%u duplicate vol list\n", (int)rctx.jcr->JobId);
958 temp_vol_list = New(dlist(vol, &vol->link));
959 foreach_dlist(vol, vol_list) {
961 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
962 memset(tvol, 0, sizeof(VOLRES));
963 tvol->vol_name = bstrdup(vol->vol_name);
964 tvol->dev = vol->dev;
965 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
967 tvol->dev = NULL; /* don't zap dev entry */
969 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
970 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
975 /* Look through reserved volumes for one we can use */
976 Dmsg1(dbglvl, "jid=%u look for vol in vol list\n", (int)rctx.jcr->JobId);
977 foreach_dlist(vol, temp_vol_list) {
979 Dmsg2(dbglvl, "jid=%u vol=%s no dev\n", (int)rctx.jcr->JobId, vol->vol_name);
982 /* Check with Director if this Volume is OK */
983 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
984 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
988 Dmsg2(dbglvl, "jid=%u vol=%s OK for this job\n", (int)rctx.jcr->JobId, vol->vol_name);
989 foreach_alist(store, dirstore) {
992 foreach_alist(device_name, store->device) {
993 /* Found a device, try to use it */
994 rctx.device_name = device_name;
995 rctx.device = vol->dev->device;
997 if (vol->dev->is_autochanger()) {
998 Dmsg2(dbglvl, "jid=%u vol=%s is in changer\n", (int)rctx.jcr->JobId,
1000 if (!is_vol_in_autochanger(rctx, vol)) {
1003 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
1004 Dmsg3(dbglvl, "jid=%u device=%s not suitable want %s\n", (int)rctx.jcr->JobId,
1005 vol->dev->device->hdr.name, device_name);
1009 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
1010 rctx.have_volume = true;
1011 /* Try reserving this device and volume */
1012 Dmsg3(dbglvl, "jid=%u try vol=%s on device=%s\n", (int)rctx.jcr->JobId,
1013 rctx.VolumeName, device_name);
1014 stat = reserve_device(rctx);
1015 if (stat == 1) { /* found available device */
1016 Dmsg2(dbglvl, "jid=%u Suitable device found=%s\n", (int)rctx.jcr->JobId,
1020 } else if (stat == 0) { /* device busy */
1021 Dmsg2(dbglvl, "jid=%u Suitable device=%s, busy: not use\n",
1022 (int)rctx.jcr->JobId, device_name);
1024 /* otherwise error */
1025 Dmsg1(dbglvl, "jid=%u No suitable device found.\n", (int)rctx.jcr->JobId);
1027 rctx.have_volume = false;
1028 rctx.VolumeName[0] = 0;
1037 } /* end for loop over reserved volumes */
1039 Dmsg1(dbglvl, "%u lock volumes\n", jid());
1041 save_vol_list = vol_list;
1042 vol_list = temp_vol_list;
1043 free_volume_list(); /* release temp_vol_list */
1044 vol_list = save_vol_list;
1045 Dmsg1(dbglvl, "jid=%u deleted temp vol list\n", (int)rctx.jcr->JobId);
1046 Dmsg1(dbglvl, "jid=%u unlock volumes\n", (int)rctx.jcr->JobId);
1050 Dmsg2(dbglvl, "jid=%u got vol %s from in-use vols list\n", (int)rctx.jcr->JobId,
1056 * No reserved volume we can use, so now search for an available device.
1058 * For each storage device that the user specified, we
1059 * search and see if there is a resource for that device.
1061 foreach_alist(store, dirstore) {
1063 foreach_alist(device_name, store->device) {
1065 rctx.device_name = device_name;
1066 stat = search_res_for_device(rctx);
1067 if (stat == 1) { /* found available device */
1068 Dmsg2(dbglvl, "jid=%u available device found=%s\n", (int)rctx.jcr->JobId,device_name);
1071 } else if (stat == 0) { /* device busy */
1072 Dmsg2(dbglvl, "jid=%u No usable device=%s, busy: not use\n", (int)rctx.jcr->JobId,device_name);
1074 /* otherwise error */
1075 Dmsg1(dbglvl, "jid=%u No usable device found.\n", (int)rctx.jcr->JobId);
1083 Dmsg1(dbglvl, "OK dev found. Vol=%s\n", rctx.VolumeName);
1085 Dmsg0(dbglvl, "Leave find_suit_dev: no dev found.\n");
1091 * Search for a particular storage device with particular storage
1092 * characteristics (MediaType).
1094 int search_res_for_device(RCTX &rctx)
1096 AUTOCHANGER *changer;
1099 Dmsg2(dbglvl, "jid=%u search res for %s\n", (int)rctx.jcr->JobId, rctx.device_name);
1100 /* Look through Autochangers first */
1101 foreach_res(changer, R_AUTOCHANGER) {
1102 Dmsg2(dbglvl, "jid=%u Try match changer res=%s\n", (int)rctx.jcr->JobId, changer->hdr.name);
1103 /* Find resource, and make sure we were able to open it */
1104 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1105 /* Try each device in this AutoChanger */
1106 foreach_alist(rctx.device, changer->device) {
1107 Dmsg2(dbglvl, "jid=%u Try changer device %s\n", (int)rctx.jcr->JobId,
1108 rctx.device->hdr.name);
1109 stat = reserve_device(rctx);
1110 if (stat != 1) { /* try another device */
1114 if (rctx.store->append == SD_APPEND) {
1115 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for append.\n",
1116 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1117 rctx.jcr->dcr->dev->num_reserved());
1119 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for read.\n",
1120 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1121 rctx.jcr->read_dcr->dev->num_reserved());
1128 /* Now if requested look through regular devices */
1129 if (!rctx.autochanger_only) {
1130 foreach_res(rctx.device, R_DEVICE) {
1131 Dmsg2(dbglvl, "jid=%u Try match res=%s\n", (int)rctx.jcr->JobId, rctx.device->hdr.name);
1132 /* Find resource, and make sure we were able to open it */
1133 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1134 stat = reserve_device(rctx);
1135 if (stat != 1) { /* try another device */
1139 if (rctx.store->append == SD_APPEND) {
1140 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for append.\n",
1141 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1142 rctx.jcr->dcr->dev->num_reserved());
1144 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for read.\n",
1145 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1146 rctx.jcr->read_dcr->dev->num_reserved());
1152 return -1; /* nothing found */
1156 * Try to reserve a specific device.
1158 * Returns: 1 -- OK, have DCR
1162 static int reserve_device(RCTX &rctx)
1166 const int name_len = MAX_NAME_LENGTH;
1168 /* Make sure MediaType is OK */
1169 Dmsg3(dbglvl, "jid=%u chk MediaType device=%s request=%s\n",
1170 (int)rctx.jcr->JobId,
1171 rctx.device->media_type, rctx.store->media_type);
1172 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1176 /* Make sure device exists -- i.e. we can stat() it */
1177 if (!rctx.device->dev) {
1178 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1180 if (!rctx.device->dev) {
1181 if (rctx.device->changer_res) {
1182 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1183 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1184 rctx.device->hdr.name, rctx.device_name);
1186 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1187 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1190 return -1; /* no use waiting */
1193 rctx.suitable_device = true;
1194 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1195 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1197 BSOCK *dir = rctx.jcr->dir_bsock;
1198 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1199 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1202 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1203 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1204 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1205 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1206 if (rctx.store->append == SD_APPEND) {
1207 Dmsg3(dbglvl, "jid=%u have_vol=%d vol=%s\n", (int)rctx.jcr->JobId,
1208 rctx.have_volume, rctx.VolumeName);
1209 ok = reserve_device_for_append(dcr, rctx);
1214 rctx.jcr->dcr = dcr;
1215 Dmsg6(dbglvl, "jid=%u Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1216 (int)rctx.jcr->JobId,
1217 dcr->dev->num_reserved(),
1218 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1219 if (rctx.have_volume) {
1220 if (reserve_volume(dcr, rctx.VolumeName)) {
1221 Dmsg2(dbglvl, "jid=%u Reserved vol=%s\n", jid(), rctx.VolumeName);
1223 Dmsg2(dbglvl, "jid=%u Could not reserve vol=%s\n", jid(), rctx.VolumeName);
1227 dcr->any_volume = true;
1228 if (dir_find_next_appendable_volume(dcr)) {
1229 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1230 Dmsg2(dbglvl, "jid=%u looking for Volume=%s\n", (int)rctx.jcr->JobId, rctx.VolumeName);
1231 rctx.have_volume = true;
1233 Dmsg1(dbglvl, "jid=%u No next volume found\n", (int)rctx.jcr->JobId);
1234 rctx.have_volume = false;
1235 rctx.VolumeName[0] = 0;
1237 * If there is at least one volume that is valid and in use,
1238 * but we get here, check if we are running with prefers
1239 * non-mounted drives. In that case, we have selected a
1240 * non-used drive and our one and only volume is mounted
1241 * elsewhere, so we bail out and retry using that drive.
1243 if (dcr->found_in_use() && !rctx.PreferMountedVols) {
1244 rctx.PreferMountedVols = true;
1245 if (dcr->VolumeName[0]) {
1246 dcr->unreserve_device();
1251 * Note. Under some circumstances, the Director can hand us
1252 * a Volume name that is not the same as the one on the current
1253 * drive, and in that case, the call above to find the next
1254 * volume will fail because in attempting to reserve the Volume
1255 * the code will realize that we already have a tape mounted,
1256 * and it will fail. This *should* only happen if there are
1257 * writers, thus the following test. In that case, we simply
1258 * bail out, and continue waiting, rather than plunging on
1259 * and hoping that the operator can resolve the problem.
1261 if (dcr->dev->num_writers != 0) {
1262 if (dcr->VolumeName[0]) {
1263 dcr->unreserve_device();
1270 ok = reserve_device_for_read(dcr);
1272 rctx.jcr->read_dcr = dcr;
1273 Dmsg6(dbglvl, "jid=%u Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1274 (int)rctx.jcr->JobId,
1275 dcr->dev->num_reserved(),
1276 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1283 if (rctx.notify_dir) {
1285 BSOCK *dir = rctx.jcr->dir_bsock;
1286 pm_strcpy(dev_name, rctx.device->hdr.name);
1287 bash_spaces(dev_name);
1288 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1289 Dmsg2(dbglvl, "jid=%u >dird changer: %s", jid(), dir->msg);
1296 rctx.have_volume = false;
1297 Dmsg1(dbglvl, "jid=%u Not OK.\n", (int)rctx.jcr->JobId);
1298 rctx.VolumeName[0] = 0;
1303 * We "reserve" the drive by setting the ST_READ bit. No one else
1304 * should touch the drive until that is cleared.
1305 * This allows the DIR to "reserve" the device before actually
1308 static bool reserve_device_for_read(DCR *dcr)
1310 DEVICE *dev = dcr->dev;
1311 JCR *jcr = dcr->jcr;
1318 if (is_device_unmounted(dev)) {
1319 Dmsg2(dbglvl, "jid=%u Device %s is BLOCKED due to user unmount.\n",
1320 (int)jcr->JobId, dev->print_name());
1321 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1322 jcr->JobId, dev->print_name());
1323 queue_reserve_message(jcr);
1327 if (dev->is_busy()) {
1328 Dmsg5(dbglvl, "jid=%u Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1329 (int)jcr->JobId, dev->print_name(),
1330 dev->state & ST_READ?1:0, dev->num_writers, dev->num_reserved());
1331 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1332 jcr->JobId, dev->print_name());
1333 queue_reserve_message(jcr);
1337 dev->clear_append();
1340 dcr->set_reserved();
1349 * We reserve the device for appending by incrementing the
1350 * num_reserved(). We do virtually all the same work that
1351 * is done in acquire_device_for_append(), but we do
1352 * not attempt to mount the device. This routine allows
1353 * the DIR to reserve multiple devices before *really*
1354 * starting the job. It also permits the SD to refuse
1355 * certain devices (not up, ...).
1357 * Note, in reserving a device, if the device is for the
1358 * same pool and the same pool type, then it is acceptable.
1359 * The Media Type has already been checked. If we are
1360 * the first tor reserve the device, we put the pool
1361 * name and pool type in the device record.
1363 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1365 JCR *jcr = dcr->jcr;
1366 DEVICE *dev = dcr->dev;
1373 /* If device is being read, we cannot write it */
1374 if (dev->can_read()) {
1375 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1376 jcr->JobId, dev->print_name());
1377 Dmsg2(dbglvl, "jid=%u %s", jid(), jcr->errmsg);
1378 queue_reserve_message(jcr);
1382 /* If device is unmounted, we are out of luck */
1383 if (is_device_unmounted(dev)) {
1384 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1385 jcr->JobId, dev->print_name());
1386 Dmsg2(dbglvl, "jid=%u %s", jid(), jcr->errmsg);
1387 queue_reserve_message(jcr);
1391 Dmsg2(dbglvl, "jid=%u reserve_append device is %s\n", jid(), dev->print_name());
1393 /* Now do detailed tests ... */
1394 if (can_reserve_drive(dcr, rctx) != 1) {
1395 Dmsg1(dbglvl, "jid=%u can_reserve_drive!=1\n", (int)jcr->JobId);
1399 dcr->set_reserved();
1407 static int is_pool_ok(DCR *dcr)
1409 DEVICE *dev = dcr->dev;
1410 JCR *jcr = dcr->jcr;
1412 /* Now check if we want the same Pool and pool type */
1413 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1414 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1415 /* OK, compatible device */
1416 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1419 /* Drive Pool not suitable for us */
1420 Mmsg(jcr->errmsg, _(
1421 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1422 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1423 dev->num_reserved(), dev->print_name());
1424 queue_reserve_message(jcr);
1425 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1426 dev->pool_name, dcr->pool_name);
1431 static bool is_max_jobs_ok(DCR *dcr)
1433 DEVICE *dev = dcr->dev;
1434 JCR *jcr = dcr->jcr;
1436 Dmsg5(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Status=%s Vol=%s\n",
1437 dcr->VolCatInfo.VolCatMaxJobs,
1438 dcr->VolCatInfo.VolCatJobs, dev->num_reserved(),
1439 dcr->VolCatInfo.VolCatStatus,
1441 if (strcmp(dcr->VolCatInfo.VolCatStatus, "Recycle") == 0) {
1444 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1445 (dcr->VolCatInfo.VolCatJobs + dev->num_reserved())) {
1446 /* Max Job Vols depassed or already reserved */
1447 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1448 (uint32_t)jcr->JobId, dev->print_name());
1449 queue_reserve_message(jcr);
1450 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1451 return false; /* wait */
1457 * Returns: 1 if drive can be reserved
1458 * 0 if we should wait
1459 * -1 on error or impossibility
1461 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1463 DEVICE *dev = dcr->dev;
1464 JCR *jcr = dcr->jcr;
1466 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1468 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1469 rctx.autochanger_only, rctx.any_drive);
1471 /* Check for max jobs on this Volume */
1472 if (!is_max_jobs_ok(dcr)) {
1476 /* setting any_drive overrides PreferMountedVols flag */
1477 if (!rctx.any_drive) {
1479 * When PreferMountedVols is set, we keep track of the
1480 * drive in use that has the least number of writers, then if
1481 * no unmounted drive is found, we try that drive. This
1482 * helps spread the load to the least used drives.
1484 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1485 Dmsg3(dbglvl, "jid=%u OK dev=%s == low_drive=%s.\n",
1486 jcr->JobId, dev->print_name(), rctx.low_use_drive->print_name());
1489 /* If he wants a free drive, but this one is busy, no go */
1490 if (!rctx.PreferMountedVols && dev->is_busy()) {
1491 /* Save least used drive */
1492 if ((dev->num_writers + dev->num_reserved()) < rctx.num_writers) {
1493 rctx.num_writers = dev->num_writers + dev->num_reserved();
1494 rctx.low_use_drive = dev;
1495 Dmsg3(dbglvl, "jid=%u set low use drive=%s num_writers=%d\n",
1496 (int)jcr->JobId, dev->print_name(), rctx.num_writers);
1498 Dmsg2(dbglvl, "jid=%u not low use num_writers=%d\n",
1499 (int)jcr->JobId, dev->num_writers+dev->num_reserved());
1501 Dmsg1(dbglvl, "jid=%u failed: !prefMnt && busy.\n", jcr->JobId);
1502 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1503 jcr->JobId, dev->print_name());
1504 queue_reserve_message(jcr);
1508 /* Check for prefer mounted volumes */
1509 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1510 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1511 jcr->JobId, dev->print_name());
1512 queue_reserve_message(jcr);
1513 Dmsg1(dbglvl, "jid=%u failed: want mounted -- no vol\n", (uint32_t)jcr->JobId);
1514 return 0; /* No volume mounted */
1517 /* Check for exact Volume name match */
1518 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1521 if (rctx.exact_match && rctx.have_volume) {
1523 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1525 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1526 rctx.autochanger_only, rctx.any_drive);
1527 Dmsg5(dbglvl, "jid=%u have_vol=%d have=%s resvol=%s want=%s\n",
1528 (int)jcr->JobId, rctx.have_volume, dev->VolHdr.VolumeName,
1529 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1530 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1531 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1533 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1534 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1536 queue_reserve_message(jcr);
1537 Dmsg4(dbglvl, "jid=%u not OK: dev have=%s resvol=%s want=%s\n", (int)jcr->JobId,
1538 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1541 if (!dcr->can_i_use_volume()) {
1542 return 0; /* fail if volume on another drive */
1547 /* Check for unused autochanger drive */
1548 if (rctx.autochanger_only && !dev->is_busy() &&
1549 dev->VolHdr.VolumeName[0] == 0) {
1550 /* Device is available but not yet reserved, reserve it for us */
1551 Dmsg2(dbglvl, "jid=%u OK Res Unused autochanger %s.\n",
1552 jcr->JobId, dev->print_name());
1553 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1554 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1555 return 1; /* reserve drive */
1559 * Handle the case that there are no writers
1561 if (dev->num_writers == 0) {
1562 /* Now check if there are any reservations on the drive */
1563 if (dev->num_reserved()) {
1564 return is_pool_ok(dcr);
1565 } else if (dev->can_append()) {
1566 if (is_pool_ok(dcr)) {
1569 /* Changing pool, unload old tape if any in drive */
1570 Dmsg1(dbglvl, "jid=%u OK dev: num_writers=0, not reserved, pool change, unload changer\n", (int)jcr->JobId);
1571 /* ***FIXME*** use set_unload() */
1572 unload_autochanger(dcr, 0);
1575 /* Device is available but not yet reserved, reserve it for us */
1576 Dmsg2(dbglvl, "jid=%u OK Dev avail reserved %s\n", (int)jcr->JobId, dev->print_name());
1577 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1578 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1579 return 1; /* reserve drive */
1583 * Check if the device is in append mode with writers (i.e.
1584 * available if pool is the same).
1586 if (dev->can_append() || dev->num_writers > 0) {
1587 return is_pool_ok(dcr);
1589 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1590 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1591 jcr->JobId, dev->print_name());
1592 queue_reserve_message(jcr);
1593 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1594 return -1; /* error, should not get here */
1596 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1597 jcr->JobId, dev->print_name());
1598 queue_reserve_message(jcr);
1599 Dmsg2(dbglvl, "jid=%u failed: No reserve %s\n", jcr->JobId, dev->print_name());
1607 * Queue a reservation error or failure message for this jcr
1609 static void queue_reserve_message(JCR *jcr)
1617 msgs = jcr->reserve_msgs;
1622 * Look for duplicate message. If found, do
1625 for (i=msgs->size()-1; i >= 0; i--) {
1626 msg = (char *)msgs->get(i);
1630 /* Comparison based on 4 digit message number */
1631 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1635 /* Message unique, so insert it */
1636 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1643 * Send any reservation messages queued for this jcr
1645 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1652 msgs = jcr->reserve_msgs;
1653 if (!msgs || msgs->size() == 0) {
1656 for (i=msgs->size()-1; i >= 0; i--) {
1657 msg = (char *)msgs->get(i);
1659 sendit(" ", 3, arg);
1660 sendit(msg, strlen(msg), arg);
1671 * Pop and release any reservations messages
1673 static void pop_reserve_messages(JCR *jcr)
1679 msgs = jcr->reserve_msgs;
1683 while ((msg = (char *)msgs->pop())) {
1691 * Also called from acquire.c
1693 void release_reserve_messages(JCR *jcr)
1695 pop_reserve_messages(jcr);
1697 if (!jcr->reserve_msgs) {
1700 delete jcr->reserve_msgs;
1701 jcr->reserve_msgs = NULL;