2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2008 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version two of the GNU General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark of John Walker.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
29 * Drive reservation functions for Storage Daemon
33 * Split from job.c and acquire.c June 2005
42 const int dbglvl = 50;
44 static dlist *vol_list = NULL;
45 static brwlock_t reservation_lock;
46 static brwlock_t vol_list_lock;
48 /* Forward referenced functions */
49 static int can_reserve_drive(DCR *dcr, RCTX &rctx);
50 static int reserve_device(RCTX &rctx);
51 static bool reserve_device_for_read(DCR *dcr);
52 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx);
53 static bool use_storage_cmd(JCR *jcr);
54 static void queue_reserve_message(JCR *jcr);
55 static void pop_reserve_messages(JCR *jcr);
56 void switch_device(DCR *dcr, DEVICE *dev);
58 /* Requests from the Director daemon */
59 static char use_storage[] = "use storage=%127s media_type=%127s "
60 "pool_name=%127s pool_type=%127s append=%d copy=%d stripe=%d\n";
61 static char use_device[] = "use device=%127s\n";
63 /* Responses sent to Director daemon */
64 static char OK_device[] = "3000 OK use device device=%s\n";
65 static char NO_device[] = "3924 Device \"%s\" not in SD Device resources.\n";
66 static char BAD_use[] = "3913 Bad use command: %s\n";
68 bool use_cmd(JCR *jcr)
71 * Get the device, media, and pool information
73 if (!use_storage_cmd(jcr)) {
74 set_jcr_job_status(jcr, JS_ErrorTerminated);
75 memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
81 static int my_compare(void *item1, void *item2)
83 return strcmp(((VOLRES *)item1)->vol_name, ((VOLRES *)item2)->vol_name);
87 * This allows a given thread to recursively call lock_reservations.
88 * It must, of course, call unlock_... the same number of times.
90 void init_reservations_lock()
93 if ((errstat=rwl_init(&reservation_lock)) != 0) {
95 Emsg1(M_ABORT, 0, _("Unable to initialize reservation lock. ERR=%s\n"),
96 be.bstrerror(errstat));
99 if ((errstat=rwl_init(&vol_list_lock)) != 0) {
101 Emsg1(M_ABORT, 0, _("Unable to initialize volume list lock. ERR=%s\n"),
102 be.bstrerror(errstat));
106 void term_reservations_lock()
108 rwl_destroy(&reservation_lock);
109 rwl_destroy(&vol_list_lock);
112 int reservations_lock_count = 0;
114 /* This applies to a drive and to Volumes */
115 void _lock_reservations()
118 reservations_lock_count++;
119 if ((errstat=rwl_writelock(&reservation_lock)) != 0) {
121 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
122 errstat, be.bstrerror(errstat));
126 void _unlock_reservations()
129 reservations_lock_count--;
130 if ((errstat=rwl_writeunlock(&reservation_lock)) != 0) {
132 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
133 errstat, be.bstrerror(errstat));
137 int vol_list_lock_count = 0;
140 * This allows a given thread to recursively call to lock_volumes()
145 vol_list_lock_count++;
146 if ((errstat=rwl_writelock(&vol_list_lock)) != 0) {
148 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
149 errstat, be.bstrerror(errstat));
153 void _unlock_volumes()
156 vol_list_lock_count--;
157 if ((errstat=rwl_writeunlock(&vol_list_lock)) != 0) {
159 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
160 errstat, be.bstrerror(errstat));
166 * List Volumes -- this should be moved to status.c
173 static void debug_list_volumes(const char *imsg)
176 POOL_MEM msg(PM_MESSAGE);
179 foreach_dlist(vol, vol_list) {
181 Mmsg(msg, "List %s: %s rel=%d on device %s\n", imsg,
182 vol->vol_name, vol->released, vol->dev->print_name());
184 Mmsg(msg, "List %s: %s rel=%d no dev\n", imsg, vol->vol_name, vol->released);
186 Dmsg1(dbglvl, "%s", msg.c_str());
191 foreach_dlist(vol, vol_list) {
192 if (vol->dev == dev) {
193 Dmsg0(dbglvl, "Two Volumes on same device.\n");
200 // Dmsg2(dbglvl, "List from %s: %d volumes\n", imsg, count);
206 * List Volumes -- this should be moved to status.c
208 void list_volumes(void sendit(const char *msg, int len, void *sarg), void *arg)
211 POOL_MEM msg(PM_MESSAGE);
215 foreach_dlist(vol, vol_list) {
216 DEVICE *dev = vol->dev;
218 len = Mmsg(msg, "%s on device %s\n", vol->vol_name, dev->print_name());
219 sendit(msg.c_str(), len, arg);
220 len = Mmsg(msg, " Reader=%d writers=%d reserved=%d released=%d\n",
221 dev->can_read()?1:0, dev->num_writers, dev->reserved_device, vol->released);
222 sendit(msg.c_str(), len, arg);
224 len = Mmsg(msg, "%s no device. released=%d\n", vol->vol_name, vol->released);
225 sendit(msg.c_str(), len, arg);
232 * Create a Volume item to put in the Volume list
233 * Ensure that the device points to it.
235 static VOLRES *new_vol_item(DCR *dcr, const char *VolumeName)
238 vol = (VOLRES *)malloc(sizeof(VOLRES));
239 memset(vol, 0, sizeof(VOLRES));
240 vol->vol_name = bstrdup(VolumeName);
242 Dmsg3(dbglvl, "new Vol=%s at %p dev=%s\n",
243 VolumeName, vol->vol_name, vol->dev->print_name());
247 static void free_vol_item(VOLRES *vol)
251 vol->dev->vol = NULL;
258 * Put a new Volume entry in the Volume list. This
259 * effectively reserves the volume so that it will
260 * not be mounted again.
262 * If the device has any current volume associated with it,
263 * and it is a different Volume, and the device is not busy,
264 * we release the old Volume item and insert the new one.
266 * It is assumed that the device is free and locked so that
267 * we can change the device structure.
269 * Some details of the Volume list handling:
271 * 1. The Volume list entry must be attached to the drive (rather than
272 * attached to a job as it currently is. I.e. the drive that "owns"
273 * the volume (reserved, in use, mounted)
274 * must point to the volume (still to be maintained in a list).
276 * 2. The Volume is entered in the list when a drive is reserved.
278 * 3. When a drive is in use, the device code must appropriately update the
279 * volume name as it changes (currently the list is static -- an entry is
280 * removed when the Volume is no longer reserved, in use or mounted).
281 * The new code must keep the same list entry as long as the drive
282 * has any volume associated with it but the volume name in the list
283 * must be updated when the drive has a different volume mounted.
285 * 4. A job that has reserved a volume, can un-reserve the volume, and if the
286 * volume is not mounted, and not reserved, and not in use, it will be
287 * removed from the list.
289 * 5. If a job wants to reserve a drive with a different Volume from the one on
290 * the drive, it can re-use the drive for the new Volume.
292 * 6. If a job wants a Volume that is in a different drive, it can either use the
293 * other drive or take the volume, only if the other drive is not in use or
296 * One nice aspect of this is that the reserve use count and the writer use count
297 * already exist and are correctly programmed and will need no changes -- use
298 * counts are always very tricky.
300 * The old code had a concept of "reserving" a Volume, but was changed
301 * to reserving and using a drive. A volume is must be attached to (owned by) a
302 * drive and can move from drive to drive or be unused given certain specific
303 * conditions of the drive. The key is that the drive must "own" the Volume.
304 * The old code had the job (dcr) owning the volume (more or less). The job was
305 * to change the insertion and removal of the volumes from the list to be based
306 * on the drive rather than the job.
308 * Return: VOLRES entry on success
309 * NULL volume busy on another drive
311 VOLRES *reserve_volume(DCR *dcr, const char *VolumeName)
314 DEVICE * volatile dev = dcr->dev;
318 Dmsg1(dbglvl, "enter reserve_volume %s\n", VolumeName);
320 * We lock the reservations system here to ensure
321 * when adding a new volume that no newly scheduled
322 * job can reserve it.
325 debug_list_volumes("begin reserve_volume");
327 * First, remove any old volume attached to this device as it
332 Dmsg4(dbglvl, "Vol attached=%s, newvol=%s release=%d on %s\n",
333 vol->vol_name, VolumeName, vol->released, dev->print_name());
335 * Make sure we don't remove the current volume we are inserting
336 * because it was probably inserted by another job, or it
337 * is not being used and is marked as released.
339 if (strcmp(vol->vol_name, VolumeName) == 0) {
340 Dmsg2(dbglvl, "=== set not released vol=%s dev=%s\n", VolumeName,
341 vol->dev->print_name());
342 vol->released = false; /* retake vol if released previously */
343 dcr->reserved_volume = true; /* reserved volume */
344 goto get_out; /* Volume already on this device */
346 /* Don't release a volume if it is in use */
347 if (!vol->released && !dcr->reserved_volume) {
348 Dmsg1(dbglvl, "Cannot free vol=%s. It is not released.\n", vol->vol_name);
349 vol = NULL; /* vol in use */
352 Dmsg2(dbglvl, "reserve_vol free vol=%s at %p\n", vol->vol_name, vol->vol_name);
353 unload_autochanger(dcr, -1); /* unload the volume */
355 debug_list_volumes("reserve_vol free");
359 /* Create a new Volume entry */
360 nvol = new_vol_item(dcr, VolumeName);
363 * Now try to insert the new Volume
365 vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
367 Dmsg2(dbglvl, "Found vol=%s dev-same=%d\n", vol->vol_name, dev==vol->dev);
369 * At this point, a Volume with this name already is in the list,
370 * so we simply release our new Volume entry. Note, this should
371 * only happen if we are moving the volume from one drive to another.
373 Dmsg2(dbglvl, "reserve_vol free-tmp vol=%s at %p\n",
374 vol->vol_name, vol->vol_name);
376 * Clear dev pointer so that free_vol_item() doesn't
377 * take away our volume.
379 nvol->dev = NULL; /* don't zap dev entry */
382 /* Check if we are trying to use the Volume on a different drive */
383 if (dev != vol->dev) {
384 /* Caller wants to switch Volume to another device */
386 Dmsg2(dbglvl, "==== Swap from dev=%s to %s\n",
387 dev->print_name(), vol->dev->print_name());
388 switch_device(dcr, vol->dev);
390 bstrncpy(dcr->VolumeName, VolumeName, sizeof(dcr->VolumeName));
392 if (!vol->dev->is_busy()) {
393 if (vol->dev->Slot > 0) {
394 Dmsg1(dbglvl, "Unload dev=%s\n", vol->dev->print_name());
395 unload_dev(dcr, vol->dev);
397 /* OK to move it -- I'm not sure this will work */
398 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n", VolumeName,
399 vol->dev->print_name(), dev->print_name());
400 vol->dev->vol = NULL; /* take vol from old drive */
401 vol->dev->VolHdr.VolumeName[0] = 0;
402 vol->dev = dev; /* point vol at new drive */
403 dev->vol = vol; /* point dev at vol */
404 dev->VolHdr.VolumeName[0] = 0;
406 Dmsg3(dbglvl, "==== Swap not possible Vol busy vol=%s from dev=%s to %s\n",
407 VolumeName, vol->dev->print_name(), dev->print_name());
408 vol = NULL; /* device busy */
418 Dmsg2(dbglvl, "=== set not released. vol=%s dev=%s\n", vol->vol_name,
419 vol->dev->print_name());
420 vol->released = false;
421 dcr->reserved_volume = true;
423 debug_list_volumes("end new volume");
429 * Switch from current device to given device
432 void switch_device(DCR *dcr, DEVICE *dev)
437 memcpy(&save_dcr, dcr, sizeof(save_dcr));
438 clean_device(dcr); /* clean up the dcr */
440 dcr->dev = dev; /* get new device pointer */
441 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
442 dcr->dev->print_name());
444 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
445 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
446 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
447 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
448 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
449 bstrncpy(dcr->dev_name, dev->dev_name, sizeof(dcr->dev_name));
451 dev->reserved_device++;
452 dcr->reserved_device = true;
458 * Search for a Volume name in the Volume list.
460 * Returns: VOLRES entry on success
461 * NULL if the Volume is not in the list
463 VOLRES *find_volume(DCR *dcr)
466 /* Do not lock reservations here */
468 vol.vol_name = bstrdup(dcr->VolumeName);
469 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
471 Dmsg2(dbglvl, "find_vol=%s found=%d\n", dcr->VolumeName, fvol!=NULL);
472 debug_list_volumes("find_volume");
478 * Remove any reservation from a drive and tell the system
479 * that the volume is unused at least by us.
481 void unreserve_device(DCR *dcr)
483 DEVICE *dev = dcr->dev;
484 if (dcr->reserved_device) {
485 dcr->reserved_device = false;
486 dcr->reserved_volume = false;
487 dev->reserved_device--;
488 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name());
489 /* If we set read mode in reserving, remove it */
490 if (dev->can_read()) {
493 if (dev->num_writers < 0) {
494 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
495 dev->num_writers = 0;
497 if (dev->reserved_device == 0 && dev->num_writers == 0) {
504 * Free a Volume from the Volume list if it is no longer used
505 * Note, for tape drives we want to remember where the Volume
506 * was when last used, so rather than free the volume entry,
507 * we simply mark it "released" so when the drive is really
508 * needed for another volume, we can reuse it.
510 * Returns: true if the Volume found and "removed" from the list
511 * false if the Volume is not in the list or is in use
513 bool volume_unused(DCR *dcr)
515 DEVICE *dev = dcr->dev;
517 if (dev->vol == NULL) {
518 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
519 debug_list_volumes("null vol cannot unreserve_volume");
524 if (dev->is_busy()) {
525 Dmsg1(dbglvl, "vol_unused: busy on %s\n", dev->print_name());
526 debug_list_volumes("dev busy cannot unreserve_volume");
531 if (dev->num_writers > 0 || dev->reserved_device > 0) {
537 * If this is a tape, we do not free the volume, rather we wait
538 * until the autoloader unloads it, or until another tape is
539 * explicitly read in this drive. This allows the SD to remember
540 * where the tapes are or last were.
542 Dmsg3(dbglvl, "=== mark released vol=%s num_writers=%d dev_reserved=%d\n",
543 dev->vol->vol_name, dev->num_writers, dev->reserved_device);
544 dev->vol->released = true;
545 Dmsg2(dbglvl, "=== set released. Vol=%s dev=%s\n", dev->vol->vol_name,
547 if (dev->is_tape() || dev->is_autochanger()) {
551 * Note, this frees the volume reservation entry, but the
552 * file descriptor remains open with the OS.
554 return free_volume(dev);
559 * Unconditionally release the volume entry
561 bool free_volume(DEVICE *dev)
565 if (dev->vol == NULL) {
566 Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name());
572 vol_list->remove(vol);
573 Dmsg2(dbglvl, "=== free_volume %s dev=%s\n", vol->vol_name, dev->print_name());
575 debug_list_volumes("free_volume");
577 // return vol != NULL;
582 /* Create the Volume list */
583 void create_volume_list()
586 if (vol_list == NULL) {
587 vol_list = New(dlist(vol, &vol->link));
591 /* Release all Volumes from the list */
592 void free_volume_list()
599 foreach_dlist(vol, vol_list) {
601 Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name());
603 Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name);
606 vol->vol_name = NULL;
613 bool is_volume_in_use(DCR *dcr)
619 vol = find_volume(dcr);
621 Dmsg1(dbglvl, "Vol=%s not in use.\n", dcr->VolumeName);
622 goto get_out; /* vol not in list */
624 ASSERT(vol->dev != NULL);
626 if (dcr->dev == vol->dev) { /* same device OK */
627 Dmsg1(dbglvl, "Vol=%s on same dev.\n", dcr->VolumeName);
630 Dmsg3(dbglvl, "Vol=%s on %s we have %s\n", dcr->VolumeName,
631 vol->dev->print_name(), dcr->dev->print_name());
633 if (!vol->dev->is_busy()) {
634 Dmsg2(dbglvl, "Vol=%s dev=%s not busy.\n", dcr->VolumeName, vol->dev->print_name());
637 Dmsg2(dbglvl, "Vol=%s dev=%s busy.\n", dcr->VolumeName, vol->dev->print_name());
639 Dmsg2(dbglvl, "Vol=%s in use by %s.\n", dcr->VolumeName, vol->dev->print_name());
650 * We get the following type of information:
652 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
656 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
660 static bool use_storage_cmd(JCR *jcr)
662 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
663 BSOCK *dir = jcr->dir_bsock;
671 memset(&rctx, 0, sizeof(RCTX));
674 * If there are multiple devices, the director sends us
675 * use_device for each device that it wants to use.
677 dirstore = New(alist(10, not_owned_by_alist));
678 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
680 Dmsg1(dbglvl, "<dird: %s", dir->msg);
681 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
682 media_type.c_str(), pool_name.c_str(),
683 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
688 jcr->write_store = dirstore;
690 jcr->read_store = dirstore;
692 rctx.append = append;
693 unbash_spaces(store_name);
694 unbash_spaces(media_type);
695 unbash_spaces(pool_name);
696 unbash_spaces(pool_type);
697 store = new DIRSTORE;
698 dirstore->append(store);
699 memset(store, 0, sizeof(DIRSTORE));
700 store->device = New(alist(10));
701 bstrncpy(store->name, store_name, sizeof(store->name));
702 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
703 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
704 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
705 store->append = append;
707 /* Now get all devices */
708 while (dir->recv() >= 0) {
709 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
710 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
714 unbash_spaces(dev_name);
715 store->device->append(bstrdup(dev_name.c_str()));
717 } while (ok && dir->recv() >= 0);
719 /* Developer debug code */
721 if (debug_level >= dbglvl) {
722 foreach_alist(store, dirstore) {
723 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
724 store->name, store->media_type, store->pool_name,
725 store->pool_type, store->append);
726 foreach_alist(device_name, store->device) {
727 Dmsg1(dbglvl, " Device=%s\n", device_name);
732 init_jcr_device_wait_timers(jcr);
733 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
735 BSOCK *dir = jcr->dir_bsock;
736 dir->fsend(_("3939 Could not get dcr\n"));
737 Dmsg1(dbglvl, ">dird: %s", dir->msg);
741 * At this point, we have a list of all the Director's Storage
742 * resources indicated for this Job, which include Pool, PoolType,
743 * storage name, and Media type.
744 * Then for each of the Storage resources, we have a list of
745 * device names that were given.
747 * Wiffle through them and find one that can do the backup.
750 int wait_for_device_retries = 0;
753 rctx.notify_dir = true;
756 for ( ; !fail && !job_canceled(jcr); ) {
757 pop_reserve_messages(jcr);
758 rctx.suitable_device = false;
759 rctx.have_volume = false;
760 rctx.VolumeName[0] = 0;
761 rctx.any_drive = false;
762 if (!jcr->PreferMountedVols) {
764 * Here we try to find a drive that is not used.
765 * This will maximize the use of available drives.
768 rctx.num_writers = 20000000; /* start with impossible number */
769 rctx.low_use_drive = NULL;
770 rctx.PreferMountedVols = false;
771 rctx.exact_match = false;
772 rctx.autochanger_only = true;
773 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
774 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
775 rctx.autochanger_only, rctx.any_drive);
776 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
779 /* Look through all drives possibly for low_use drive */
780 if (rctx.low_use_drive) {
781 rctx.try_low_use_drive = true;
782 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
785 rctx.try_low_use_drive = false;
787 rctx.autochanger_only = false;
788 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
789 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
790 rctx.autochanger_only, rctx.any_drive);
791 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
796 * Now we look for a drive that may or may not be in
799 /* Look for an exact Volume match all drives */
800 rctx.PreferMountedVols = true;
801 rctx.exact_match = true;
802 rctx.autochanger_only = false;
803 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
804 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
805 rctx.autochanger_only, rctx.any_drive);
806 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
809 /* Look for any mounted drive */
810 rctx.exact_match = false;
811 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
812 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
813 rctx.autochanger_only, rctx.any_drive);
814 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
818 rctx.any_drive = true;
819 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
820 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
821 rctx.autochanger_only, rctx.any_drive);
822 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
825 /* Keep reservations locked *except* during wait_for_device() */
826 unlock_reservations();
828 * The idea of looping on repeat a few times it to ensure
829 * that if there is some subtle timing problem between two
830 * jobs, we will simply try again, and most likely succeed.
831 * This can happen if one job reserves a drive or finishes using
832 * a drive at the same time a second job wants it.
834 if (repeat++ > 1) { /* try algorithm 3 times */
835 bmicrosleep(30, 0); /* wait a bit */
836 Dmsg0(dbglvl, "repeat reserve algorithm\n");
837 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
838 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
842 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
844 unlock_reservations();
847 * If we get here, there are no suitable devices available, which
848 * means nothing configured. If a device is suitable but busy
849 * with another Volume, we will not come here.
851 unbash_spaces(dir->msg);
852 pm_strcpy(jcr->errmsg, dir->msg);
853 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
854 Jmsg(jcr, M_FATAL, 0, _("\n"
855 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
856 dev_name.c_str(), media_type.c_str());
857 dir->fsend(NO_device, dev_name.c_str());
859 Dmsg1(dbglvl, ">dird: %s", dir->msg);
862 unbash_spaces(dir->msg);
863 pm_strcpy(jcr->errmsg, dir->msg);
864 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
865 dir->fsend(BAD_use, jcr->errmsg);
866 Dmsg1(dbglvl, ">dird: %s", dir->msg);
869 release_reserve_messages(jcr);
875 * Walk through the autochanger resources and check if
876 * the volume is in one of them.
878 * Returns: true if volume is in device
881 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
883 AUTOCHANGER *changer = vol->dev->device->changer_res;
885 /* Find resource, and make sure we were able to open it */
886 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
887 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
890 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
895 * Search for a device suitable for this job.
896 * Note, this routine sets sets rctx.suitable_device if any
897 * device exists within the SD. The device may not be actually
899 * It also returns if it finds a useable device.
901 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
910 dirstore = jcr->write_store;
912 dirstore = jcr->read_store;
914 Dmsg4(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
915 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
916 rctx.autochanger_only);
919 * If the appropriate conditions of this if are met, namely that
920 * we are appending and the user wants mounted drive (or we
921 * force try a mounted drive because they are all busy), we
922 * start by looking at all the Volumes in the volume list.
924 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
925 dlist *temp_vol_list, *save_vol_list;
928 Dmsg0(dbglvl, "lock volumes\n");
931 * Create a temporary copy of the volume list. We do this,
932 * to avoid having the volume list locked during the
933 * call to reserve_device(), which would cause a deadlock.
934 * Note, we may want to add an update counter on the vol_list
935 * so that if it is modified while we are traversing the copy
936 * we can take note and act accordingly (probably redo the
937 * search at least a few times).
939 Dmsg0(dbglvl, "duplicate vol list\n");
940 temp_vol_list = New(dlist(vol, &vol->link));
941 foreach_dlist(vol, vol_list) {
943 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
944 memset(tvol, 0, sizeof(VOLRES));
945 tvol->vol_name = bstrdup(vol->vol_name);
946 tvol->dev = vol->dev;
947 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
949 tvol->dev = NULL; /* don't zap dev entry */
951 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
952 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
955 Dmsg0(dbglvl, "unlock volumes\n");
958 /* Look through reserved volumes for one we can use */
959 Dmsg0(dbglvl, "look for vol in vol list\n");
960 foreach_dlist(vol, temp_vol_list) {
962 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
965 /* Check with Director if this Volume is OK */
966 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
967 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
971 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
972 foreach_alist(store, dirstore) {
975 foreach_alist(device_name, store->device) {
976 /* Found a device, try to use it */
977 rctx.device_name = device_name;
978 rctx.device = vol->dev->device;
980 if (vol->dev->is_autochanger()) {
981 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
982 if (!is_vol_in_autochanger(rctx, vol)) {
985 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
986 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
987 vol->dev->device->hdr.name, device_name);
991 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
992 rctx.have_volume = true;
993 /* Try reserving this device and volume */
994 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
995 stat = reserve_device(rctx);
996 if (stat == 1) { /* found available device */
997 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
1000 } else if (stat == 0) { /* device busy */
1001 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
1003 /* otherwise error */
1004 Dmsg0(dbglvl, "No suitable device found.\n");
1006 rctx.have_volume = false;
1007 rctx.VolumeName[0] = 0;
1016 } /* end for loop over reserved volumes */
1018 Dmsg0(dbglvl, "lock volumes\n");
1020 save_vol_list = vol_list;
1021 vol_list = temp_vol_list;
1022 free_volume_list(); /* release temp_vol_list */
1023 vol_list = save_vol_list;
1024 Dmsg0(dbglvl, "deleted temp vol list\n");
1025 Dmsg0(dbglvl, "unlock volumes\n");
1027 debug_list_volumes("=== After free temp table\n");
1030 Dmsg1(dbglvl, "Usable dev found. Vol=%s from in-use vols list\n", rctx.VolumeName);
1035 * No reserved volume we can use, so now search for an available device.
1037 * For each storage device that the user specified, we
1038 * search and see if there is a resource for that device.
1040 foreach_alist(store, dirstore) {
1042 foreach_alist(device_name, store->device) {
1044 rctx.device_name = device_name;
1045 stat = search_res_for_device(rctx);
1046 if (stat == 1) { /* found available device */
1047 Dmsg1(dbglvl, "available device found=%s\n", device_name);
1050 } else if (stat == 0) { /* device busy */
1051 Dmsg1(dbglvl, "No usable device=%s, busy: not use\n", device_name);
1053 /* otherwise error */
1054 Dmsg0(dbglvl, "No usable device found.\n");
1062 Dmsg1(dbglvl, "Usable dev found. Vol=%s\n", rctx.VolumeName);
1068 * Search for a particular storage device with particular storage
1069 * characteristics (MediaType).
1071 int search_res_for_device(RCTX &rctx)
1073 AUTOCHANGER *changer;
1076 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
1077 /* Look through Autochangers first */
1078 foreach_res(changer, R_AUTOCHANGER) {
1079 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
1080 /* Find resource, and make sure we were able to open it */
1081 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1082 /* Try each device in this AutoChanger */
1083 foreach_alist(rctx.device, changer->device) {
1084 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
1085 stat = reserve_device(rctx);
1086 if (stat != 1) { /* try another device */
1090 if (rctx.store->append == SD_APPEND) {
1091 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1092 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1094 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1095 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1102 /* Now if requested look through regular devices */
1103 if (!rctx.autochanger_only) {
1104 foreach_res(rctx.device, R_DEVICE) {
1105 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
1106 /* Find resource, and make sure we were able to open it */
1107 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1108 stat = reserve_device(rctx);
1109 if (stat != 1) { /* try another device */
1113 if (rctx.store->append == SD_APPEND) {
1114 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1115 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1117 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1118 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1124 return -1; /* nothing found */
1128 * Try to reserve a specific device.
1130 * Returns: 1 -- OK, have DCR
1134 static int reserve_device(RCTX &rctx)
1138 const int name_len = MAX_NAME_LENGTH;
1140 /* Make sure MediaType is OK */
1141 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
1142 rctx.device->media_type, rctx.store->media_type);
1143 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1147 /* Make sure device exists -- i.e. we can stat() it */
1148 if (!rctx.device->dev) {
1149 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1151 if (!rctx.device->dev) {
1152 if (rctx.device->changer_res) {
1153 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1154 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1155 rctx.device->hdr.name, rctx.device_name);
1157 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1158 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1161 return -1; /* no use waiting */
1164 rctx.suitable_device = true;
1165 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1166 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1168 BSOCK *dir = rctx.jcr->dir_bsock;
1169 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1170 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1173 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1174 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1175 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1176 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1177 if (rctx.store->append == SD_APPEND) {
1178 Dmsg2(dbglvl, "call reserve for append: have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
1179 ok = reserve_device_for_append(dcr, rctx);
1184 rctx.jcr->dcr = dcr;
1185 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1186 dcr->dev->reserved_device,
1187 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1188 Dmsg3(dbglvl, "Vol=%s num_writers=%d, have_vol=%d\n",
1189 rctx.VolumeName, dcr->dev->num_writers, rctx.have_volume);
1190 if (rctx.have_volume) {
1191 Dmsg0(dbglvl, "Call reserve_volume\n");
1192 if (reserve_volume(dcr, rctx.VolumeName)) {
1193 Dmsg1(dbglvl, "Reserved vol=%s\n", rctx.VolumeName);
1195 Dmsg1(dbglvl, "Could not reserve vol=%s\n", rctx.VolumeName);
1199 dcr->any_volume = true;
1200 Dmsg0(dbglvl, "no vol, call find_next_appendable_vol.\n");
1201 if (dir_find_next_appendable_volume(dcr)) {
1202 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1203 rctx.have_volume = true;
1204 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
1206 Dmsg0(dbglvl, "No next volume found\n");
1207 rctx.have_volume = false;
1208 rctx.VolumeName[0] = 0;
1210 * If there is at least one volume that is valid and in use,
1211 * but we get here, check if we are running with prefers
1212 * non-mounted drives. In that case, we have selected a
1213 * non-used drive and our one and only volume is mounted
1214 * elsewhere, so we bail out and retry using that drive.
1216 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1217 rctx.PreferMountedVols = true;
1218 if (dcr->VolumeName[0]) {
1219 unreserve_device(dcr);
1224 * Note. Under some circumstances, the Director can hand us
1225 * a Volume name that is not the same as the one on the current
1226 * drive, and in that case, the call above to find the next
1227 * volume will fail because in attempting to reserve the Volume
1228 * the code will realize that we already have a tape mounted,
1229 * and it will fail. This *should* only happen if there are
1230 * writers, thus the following test. In that case, we simply
1231 * bail out, and continue waiting, rather than plunging on
1232 * and hoping that the operator can resolve the problem.
1234 if (dcr->dev->num_writers != 0) {
1235 if (dcr->VolumeName[0]) {
1236 unreserve_device(dcr);
1243 ok = reserve_device_for_read(dcr);
1245 rctx.jcr->read_dcr = dcr;
1246 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1247 dcr->dev->reserved_device,
1248 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1255 if (rctx.notify_dir) {
1257 BSOCK *dir = rctx.jcr->dir_bsock;
1258 pm_strcpy(dev_name, rctx.device->hdr.name);
1259 bash_spaces(dev_name);
1260 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1261 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1268 rctx.have_volume = false;
1269 rctx.VolumeName[0] = 0;
1270 Dmsg0(dbglvl, "Not OK.\n");
1275 * We "reserve" the drive by setting the ST_READ bit. No one else
1276 * should touch the drive until that is cleared.
1277 * This allows the DIR to "reserve" the device before actually
1280 static bool reserve_device_for_read(DCR *dcr)
1282 DEVICE *dev = dcr->dev;
1283 JCR *jcr = dcr->jcr;
1290 if (is_device_unmounted(dev)) {
1291 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
1292 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1293 jcr->JobId, dev->print_name());
1294 queue_reserve_message(jcr);
1298 if (dev->is_busy()) {
1299 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1301 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1302 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1303 jcr->JobId, dev->print_name());
1304 queue_reserve_message(jcr);
1308 dev->clear_append();
1311 dev->reserved_device++;
1312 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev);
1313 dcr->reserved_device = true;
1322 * We reserve the device for appending by incrementing the
1323 * reserved_device. We do virtually all the same work that
1324 * is done in acquire_device_for_append(), but we do
1325 * not attempt to mount the device. This routine allows
1326 * the DIR to reserve multiple devices before *really*
1327 * starting the job. It also permits the SD to refuse
1328 * certain devices (not up, ...).
1330 * Note, in reserving a device, if the device is for the
1331 * same pool and the same pool type, then it is acceptable.
1332 * The Media Type has already been checked. If we are
1333 * the first tor reserve the device, we put the pool
1334 * name and pool type in the device record.
1336 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1338 JCR *jcr = dcr->jcr;
1339 DEVICE *dev = dcr->dev;
1346 /* If device is being read, we cannot write it */
1347 if (dev->can_read()) {
1348 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1349 jcr->JobId, dev->print_name());
1350 Dmsg1(dbglvl, "%s", jcr->errmsg);
1351 queue_reserve_message(jcr);
1355 /* If device is unmounted, we are out of luck */
1356 if (is_device_unmounted(dev)) {
1357 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1358 jcr->JobId, dev->print_name());
1359 Dmsg1(dbglvl, "%s", jcr->errmsg);
1360 queue_reserve_message(jcr);
1364 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
1366 /* Now do detailed tests ... */
1367 if (can_reserve_drive(dcr, rctx) != 1) {
1368 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
1372 dev->reserved_device++;
1373 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device,
1374 dev->print_name(), dev);
1375 dcr->reserved_device = true;
1383 static int is_pool_ok(DCR *dcr)
1385 DEVICE *dev = dcr->dev;
1386 JCR *jcr = dcr->jcr;
1388 /* Now check if we want the same Pool and pool type */
1389 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1390 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1391 /* OK, compatible device */
1392 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1395 /* Drive Pool not suitable for us */
1396 Mmsg(jcr->errmsg, _(
1397 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1398 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1399 dev->reserved_device, dev->print_name());
1400 queue_reserve_message(jcr);
1401 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1402 dev->pool_name, dcr->pool_name);
1407 static bool is_max_jobs_ok(DCR *dcr)
1409 DEVICE *dev = dcr->dev;
1410 JCR *jcr = dcr->jcr;
1412 Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n",
1413 dcr->VolCatInfo.VolCatMaxJobs,
1414 dcr->VolCatInfo.VolCatJobs, dev->reserved_device,
1416 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1417 (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) {
1418 /* Max Job Vols depassed or already reserved */
1419 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1420 (uint32_t)jcr->JobId, dev->print_name());
1421 queue_reserve_message(jcr);
1422 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1423 return false; /* wait */
1429 * Returns: 1 if drive can be reserved
1430 * 0 if we should wait
1431 * -1 on error or impossibility
1433 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1435 DEVICE *dev = dcr->dev;
1436 JCR *jcr = dcr->jcr;
1438 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1439 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1440 rctx.autochanger_only, rctx.any_drive);
1442 /* Check for max jobs on this Volume */
1443 if (!is_max_jobs_ok(dcr)) {
1447 /* setting any_drive overrides PreferMountedVols flag */
1448 if (!rctx.any_drive) {
1450 * When PreferMountedVols is set, we keep track of the
1451 * drive in use that has the least number of writers, then if
1452 * no unmounted drive is found, we try that drive. This
1453 * helps spread the load to the least used drives.
1455 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1456 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
1457 dev->print_name(), rctx.low_use_drive->print_name());
1460 /* If he wants a free drive, but this one is busy, no go */
1461 if (!rctx.PreferMountedVols && dev->is_busy()) {
1462 /* Save least used drive */
1463 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1464 rctx.num_writers = dev->num_writers + dev->reserved_device;
1465 rctx.low_use_drive = dev;
1466 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
1467 dev->print_name(), rctx.num_writers);
1469 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->reserved_device);
1471 Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
1472 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1473 jcr->JobId, dev->print_name());
1474 queue_reserve_message(jcr);
1478 /* Check for prefer mounted volumes */
1479 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1480 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1481 jcr->JobId, dev->print_name());
1482 queue_reserve_message(jcr);
1483 Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
1484 return 0; /* No volume mounted */
1487 /* Check for exact Volume name match */
1488 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1491 if (rctx.exact_match && rctx.have_volume) {
1493 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1494 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1495 rctx.autochanger_only, rctx.any_drive);
1496 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1497 rctx.have_volume, dev->VolHdr.VolumeName,
1498 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1499 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1500 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1502 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1503 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1505 queue_reserve_message(jcr);
1506 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1507 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1510 if (is_volume_in_use(dcr)) {
1511 return 0; /* fail if volume on another drive */
1516 /* Check for unused autochanger drive */
1517 if (rctx.autochanger_only && !dev->is_busy() &&
1518 dev->VolHdr.VolumeName[0] == 0) {
1519 /* Device is available but not yet reserved, reserve it for us */
1520 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1521 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1522 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1523 return 1; /* reserve drive */
1527 * Handle the case that there are no writers
1529 if (dev->num_writers == 0) {
1530 /* Now check if there are any reservations on the drive */
1531 if (dev->reserved_device) {
1532 return is_pool_ok(dcr);
1533 } else if (dev->can_append()) {
1534 if (is_pool_ok(dcr)) {
1537 /* Changing pool, unload old tape if any in drive */
1538 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1539 unload_autochanger(dcr, 0);
1542 /* Device is available but not yet reserved, reserve it for us */
1543 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1544 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1545 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1546 return 1; /* reserve drive */
1550 * Check if the device is in append mode with writers (i.e.
1551 * available if pool is the same).
1553 if (dev->can_append() || dev->num_writers > 0) {
1554 return is_pool_ok(dcr);
1556 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1557 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1558 jcr->JobId, dev->print_name());
1559 queue_reserve_message(jcr);
1560 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1561 return -1; /* error, should not get here */
1563 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1564 jcr->JobId, dev->print_name());
1565 queue_reserve_message(jcr);
1566 Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1574 * Queue a reservation error or failure message for this jcr
1576 static void queue_reserve_message(JCR *jcr)
1584 msgs = jcr->reserve_msgs;
1589 * Look for duplicate message. If found, do
1592 for (i=msgs->size()-1; i >= 0; i--) {
1593 msg = (char *)msgs->get(i);
1597 /* Comparison based on 4 digit message number */
1598 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1602 /* Message unique, so insert it */
1603 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1610 * Send any reservation messages queued for this jcr
1612 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1619 msgs = jcr->reserve_msgs;
1620 if (!msgs || msgs->size() == 0) {
1623 for (i=msgs->size()-1; i >= 0; i--) {
1624 msg = (char *)msgs->get(i);
1626 sendit(" ", 3, arg);
1627 sendit(msg, strlen(msg), arg);
1638 * Pop and release any reservations messages
1640 static void pop_reserve_messages(JCR *jcr)
1646 msgs = jcr->reserve_msgs;
1650 while ((msg = (char *)msgs->pop())) {
1658 * Also called from acquire.c
1660 void release_reserve_messages(JCR *jcr)
1662 pop_reserve_messages(jcr);
1664 if (!jcr->reserve_msgs) {
1667 delete jcr->reserve_msgs;
1668 jcr->reserve_msgs = NULL;