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 */
385 Dmsg2(dbglvl, "==== Swap from dev=%s to %s\n",
386 dev->print_name(), vol->dev->print_name());
387 switch_device(dcr, vol->dev);
389 bstrncpy(dcr->VolumeName, VolumeName, sizeof(dcr->VolumeName));
391 if (!vol->dev->is_busy()) {
392 /* OK to move it -- I'm not sure this will work */
393 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n", VolumeName,
394 vol->dev->print_name(), dev->print_name());
395 vol->dev->vol = NULL; /* take vol from old drive */
396 vol->dev->VolHdr.VolumeName[0] = 0;
397 vol->dev = dev; /* point vol at new drive */
398 dev->vol = vol; /* point dev at vol */
399 dev->VolHdr.VolumeName[0] = 0;
401 Dmsg3(dbglvl, "==== Swap not possible Vol busy vol=%s from dev=%s to %s\n",
402 VolumeName, vol->dev->print_name(), dev->print_name());
403 vol = NULL; /* device busy */
413 Dmsg2(dbglvl, "=== set not released. vol=%s dev=%s\n", vol->vol_name,
414 vol->dev->print_name());
415 vol->released = false;
416 dcr->reserved_volume = true;
418 debug_list_volumes("end new volume");
424 * Switch from current device to given device
427 void switch_device(DCR *dcr, DEVICE *dev)
429 // lock_reservations();
433 memcpy(&save_dcr, dcr, sizeof(save_dcr));
434 clean_device(dcr); /* clean up the dcr */
436 dcr->dev = dev; /* get new device pointer */
437 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
438 dcr->dev->print_name());
440 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
441 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
442 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
443 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
444 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
445 bstrncpy(dcr->dev_name, dev->dev_name, sizeof(dcr->dev_name));
447 dev->reserved_device++;
448 dcr->reserved_device = true;
454 * Search for a Volume name in the Volume list.
456 * Returns: VOLRES entry on success
457 * NULL if the Volume is not in the list
459 VOLRES *find_volume(DCR *dcr)
462 /* Do not lock reservations here */
464 vol.vol_name = bstrdup(dcr->VolumeName);
465 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
467 Dmsg2(dbglvl, "find_vol=%s found=%d\n", dcr->VolumeName, fvol!=NULL);
468 debug_list_volumes("find_volume");
474 * Remove any reservation from a drive and tell the system
475 * that the volume is unused at least by us.
477 void unreserve_device(DCR *dcr)
479 DEVICE *dev = dcr->dev;
480 if (dcr->reserved_device) {
481 dcr->reserved_device = false;
482 dcr->reserved_volume = false;
483 dev->reserved_device--;
484 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name());
485 /* If we set read mode in reserving, remove it */
486 if (dev->can_read()) {
489 if (dev->num_writers < 0) {
490 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
491 dev->num_writers = 0;
493 if (dev->reserved_device == 0 && dev->num_writers == 0) {
500 * Free a Volume from the Volume list if it is no longer used
501 * Note, for tape drives we want to remember where the Volume
502 * was when last used, so rather than free the volume entry,
503 * we simply mark it "released" so when the drive is really
504 * needed for another volume, we can reuse it.
506 * Returns: true if the Volume found and "removed" from the list
507 * false if the Volume is not in the list or is in use
509 bool volume_unused(DCR *dcr)
511 DEVICE *dev = dcr->dev;
513 if (dev->vol == NULL) {
514 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
515 debug_list_volumes("null vol cannot unreserve_volume");
520 if (dev->is_busy()) {
521 Dmsg1(dbglvl, "vol_unused: busy on %s\n", dev->print_name());
522 debug_list_volumes("dev busy cannot unreserve_volume");
527 if (dev->num_writers > 0 || dev->reserved_device > 0) {
533 * If this is a tape, we do not free the volume, rather we wait
534 * until the autoloader unloads it, or until another tape is
535 * explicitly read in this drive. This allows the SD to remember
536 * where the tapes are or last were.
538 Dmsg3(dbglvl, "=== mark released vol=%s num_writers=%d dev_reserved=%d\n",
539 dev->vol->vol_name, dev->num_writers, dev->reserved_device);
540 dev->vol->released = true;
541 Dmsg2(dbglvl, "=== set released. Vol=%s dev=%s\n", dev->vol->vol_name,
543 if (dev->is_tape()) { // || dev->is_autochanger()) {
547 * Note, this frees the volume reservation entry, but the
548 * file descriptor remains open with the OS.
550 return free_volume(dev);
555 * Unconditionally release the volume entry
557 bool free_volume(DEVICE *dev)
561 if (dev->vol == NULL) {
562 Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name());
568 vol_list->remove(vol);
569 Dmsg2(dbglvl, "=== free_volume %s dev=%s\n", vol->vol_name, dev->print_name());
571 debug_list_volumes("free_volume");
573 // return vol != NULL;
578 /* Create the Volume list */
579 void create_volume_list()
582 if (vol_list == NULL) {
583 vol_list = New(dlist(vol, &vol->link));
587 /* Release all Volumes from the list */
588 void free_volume_list()
595 foreach_dlist(vol, vol_list) {
597 Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name());
599 Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name);
602 vol->vol_name = NULL;
609 bool is_volume_in_use(DCR *dcr)
611 VOLRES *vol = find_volume(dcr);
613 Dmsg1(dbglvl, "Vol=%s not in use.\n", dcr->VolumeName);
614 return false; /* vol not in list */
616 ASSERT(vol->dev != NULL);
618 if (dcr->dev == vol->dev) { /* same device OK */
619 Dmsg1(dbglvl, "Vol=%s on same dev.\n", dcr->VolumeName);
622 Dmsg3(dbglvl, "Vol=%s on %s we have %s\n", dcr->VolumeName,
623 vol->dev->print_name(), dcr->dev->print_name());
625 if (!vol->dev->is_busy()) {
626 Dmsg2(dbglvl, "Vol=%s dev=%s not busy.\n", dcr->VolumeName, vol->dev->print_name());
629 Dmsg2(dbglvl, "Vol=%s dev=%s busy.\n", dcr->VolumeName, vol->dev->print_name());
631 Dmsg2(dbglvl, "Vol=%s in use by %s.\n", dcr->VolumeName, vol->dev->print_name());
637 * We get the following type of information:
639 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
643 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
647 static bool use_storage_cmd(JCR *jcr)
649 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
650 BSOCK *dir = jcr->dir_bsock;
658 memset(&rctx, 0, sizeof(RCTX));
661 * If there are multiple devices, the director sends us
662 * use_device for each device that it wants to use.
664 dirstore = New(alist(10, not_owned_by_alist));
665 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
667 Dmsg1(dbglvl, "<dird: %s", dir->msg);
668 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
669 media_type.c_str(), pool_name.c_str(),
670 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
675 jcr->write_store = dirstore;
677 jcr->read_store = dirstore;
679 rctx.append = append;
680 unbash_spaces(store_name);
681 unbash_spaces(media_type);
682 unbash_spaces(pool_name);
683 unbash_spaces(pool_type);
684 store = new DIRSTORE;
685 dirstore->append(store);
686 memset(store, 0, sizeof(DIRSTORE));
687 store->device = New(alist(10));
688 bstrncpy(store->name, store_name, sizeof(store->name));
689 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
690 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
691 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
692 store->append = append;
694 /* Now get all devices */
695 while (dir->recv() >= 0) {
696 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
697 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
701 unbash_spaces(dev_name);
702 store->device->append(bstrdup(dev_name.c_str()));
704 } while (ok && dir->recv() >= 0);
706 /* Developer debug code */
708 if (debug_level >= dbglvl) {
709 foreach_alist(store, dirstore) {
710 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
711 store->name, store->media_type, store->pool_name,
712 store->pool_type, store->append);
713 foreach_alist(device_name, store->device) {
714 Dmsg1(dbglvl, " Device=%s\n", device_name);
719 init_jcr_device_wait_timers(jcr);
720 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
722 BSOCK *dir = jcr->dir_bsock;
723 dir->fsend(_("3939 Could not get dcr\n"));
724 Dmsg1(dbglvl, ">dird: %s", dir->msg);
728 * At this point, we have a list of all the Director's Storage
729 * resources indicated for this Job, which include Pool, PoolType,
730 * storage name, and Media type.
731 * Then for each of the Storage resources, we have a list of
732 * device names that were given.
734 * Wiffle through them and find one that can do the backup.
737 int wait_for_device_retries = 0;
740 rctx.notify_dir = true;
743 for ( ; !fail && !job_canceled(jcr); ) {
744 pop_reserve_messages(jcr);
745 rctx.suitable_device = false;
746 rctx.have_volume = false;
747 rctx.VolumeName[0] = 0;
748 rctx.any_drive = false;
749 if (!jcr->PreferMountedVols) {
751 * Here we try to find a drive that is not used.
752 * This will maximize the use of available drives.
755 rctx.num_writers = 20000000; /* start with impossible number */
756 rctx.low_use_drive = NULL;
757 rctx.PreferMountedVols = false;
758 rctx.exact_match = false;
759 rctx.autochanger_only = true;
760 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
761 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
762 rctx.autochanger_only, rctx.any_drive);
763 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
766 /* Look through all drives possibly for low_use drive */
767 if (rctx.low_use_drive) {
768 rctx.try_low_use_drive = true;
769 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
772 rctx.try_low_use_drive = false;
774 rctx.autochanger_only = false;
775 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
776 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
777 rctx.autochanger_only, rctx.any_drive);
778 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
783 * Now we look for a drive that may or may not be in
786 /* Look for an exact Volume match all drives */
787 rctx.PreferMountedVols = true;
788 rctx.exact_match = true;
789 rctx.autochanger_only = false;
790 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
791 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
792 rctx.autochanger_only, rctx.any_drive);
793 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
796 /* Look for any mounted drive */
797 rctx.exact_match = false;
798 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
799 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
800 rctx.autochanger_only, rctx.any_drive);
801 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
805 rctx.any_drive = true;
806 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
807 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
808 rctx.autochanger_only, rctx.any_drive);
809 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
812 /* Keep reservations locked *except* during wait_for_device() */
813 unlock_reservations();
815 * The idea of looping on repeat a few times it to ensure
816 * that if there is some subtle timing problem between two
817 * jobs, we will simply try again, and most likely succeed.
818 * This can happen if one job reserves a drive or finishes using
819 * a drive at the same time a second job wants it.
821 if (repeat++ > 1) { /* try algorithm 3 times */
822 bmicrosleep(30, 0); /* wait a bit */
823 Dmsg0(dbglvl, "repeat reserve algorithm\n");
824 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
825 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
829 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
831 unlock_reservations();
834 * If we get here, there are no suitable devices available, which
835 * means nothing configured. If a device is suitable but busy
836 * with another Volume, we will not come here.
838 unbash_spaces(dir->msg);
839 pm_strcpy(jcr->errmsg, dir->msg);
840 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
841 Jmsg(jcr, M_FATAL, 0, _("\n"
842 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
843 dev_name.c_str(), media_type.c_str());
844 dir->fsend(NO_device, dev_name.c_str());
846 Dmsg1(dbglvl, ">dird: %s", dir->msg);
849 unbash_spaces(dir->msg);
850 pm_strcpy(jcr->errmsg, dir->msg);
851 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
852 dir->fsend(BAD_use, jcr->errmsg);
853 Dmsg1(dbglvl, ">dird: %s", dir->msg);
856 release_reserve_messages(jcr);
862 * Walk through the autochanger resources and check if
863 * the volume is in one of them.
865 * Returns: true if volume is in device
868 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
870 AUTOCHANGER *changer = vol->dev->device->changer_res;
872 /* Find resource, and make sure we were able to open it */
873 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
874 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
877 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
882 * Search for a device suitable for this job.
883 * Note, this routine sets sets rctx.suitable_device if any
884 * device exists within the SD. The device may not be actually
886 * It also returns if it finds a useable device.
888 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
897 dirstore = jcr->write_store;
899 dirstore = jcr->read_store;
901 Dmsg4(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
902 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
903 rctx.autochanger_only);
906 * If the appropriate conditions of this if are met, namely that
907 * we are appending and the user wants mounted drive (or we
908 * force try a mounted drive because they are all busy), we
909 * start by looking at all the Volumes in the volume list.
911 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
912 dlist *temp_vol_list, *save_vol_list;
915 Dmsg0(dbglvl, "lock volumes\n");
918 * Create a temporary copy of the volume list. We do this,
919 * to avoid having the volume list locked during the
920 * call to reserve_device(), which would cause a deadlock.
921 * Note, we may want to add an update counter on the vol_list
922 * so that if it is modified while we are traversing the copy
923 * we can take note and act accordingly (probably redo the
924 * search at least a few times).
926 Dmsg0(dbglvl, "duplicate vol list\n");
927 temp_vol_list = New(dlist(vol, &vol->link));
928 foreach_dlist(vol, vol_list) {
930 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
931 memset(tvol, 0, sizeof(VOLRES));
932 tvol->vol_name = bstrdup(vol->vol_name);
933 tvol->dev = vol->dev;
934 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
936 tvol->dev = NULL; /* don't zap dev entry */
938 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
939 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
942 Dmsg0(dbglvl, "unlock volumes\n");
945 /* Look through reserved volumes for one we can use */
946 Dmsg0(dbglvl, "look for vol in vol list\n");
947 foreach_dlist(vol, temp_vol_list) {
949 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
952 /* Check with Director if this Volume is OK */
953 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
954 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
958 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
959 foreach_alist(store, dirstore) {
962 foreach_alist(device_name, store->device) {
963 /* Found a device, try to use it */
964 rctx.device_name = device_name;
965 rctx.device = vol->dev->device;
967 if (vol->dev->is_autochanger()) {
968 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
969 if (!is_vol_in_autochanger(rctx, vol)) {
972 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
973 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
974 vol->dev->device->hdr.name, device_name);
978 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
979 rctx.have_volume = true;
980 /* Try reserving this device and volume */
981 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
982 stat = reserve_device(rctx);
983 if (stat == 1) { /* found available device */
984 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
987 } else if (stat == 0) { /* device busy */
988 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
990 /* otherwise error */
991 Dmsg0(dbglvl, "No suitable device found.\n");
993 rctx.have_volume = false;
994 rctx.VolumeName[0] = 0;
1003 } /* end for loop over reserved volumes */
1005 Dmsg0(dbglvl, "lock volumes\n");
1007 save_vol_list = vol_list;
1008 vol_list = temp_vol_list;
1009 free_volume_list(); /* release temp_vol_list */
1010 vol_list = save_vol_list;
1011 Dmsg0(dbglvl, "deleted temp vol list\n");
1012 Dmsg0(dbglvl, "unlock volumes\n");
1014 debug_list_volumes("=== After free temp table\n");
1017 Dmsg1(dbglvl, "Usable dev found. Vol=%s from in-use vols list\n", rctx.VolumeName);
1022 * No reserved volume we can use, so now search for an available device.
1024 * For each storage device that the user specified, we
1025 * search and see if there is a resource for that device.
1027 foreach_alist(store, dirstore) {
1029 foreach_alist(device_name, store->device) {
1031 rctx.device_name = device_name;
1032 stat = search_res_for_device(rctx);
1033 if (stat == 1) { /* found available device */
1034 Dmsg1(dbglvl, "available device found=%s\n", device_name);
1037 } else if (stat == 0) { /* device busy */
1038 Dmsg1(dbglvl, "No usable device=%s, busy: not use\n", device_name);
1040 /* otherwise error */
1041 Dmsg0(dbglvl, "No usable device found.\n");
1049 Dmsg1(dbglvl, "Usable dev found. Vol=%s\n", rctx.VolumeName);
1055 * Search for a particular storage device with particular storage
1056 * characteristics (MediaType).
1058 int search_res_for_device(RCTX &rctx)
1060 AUTOCHANGER *changer;
1063 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
1064 /* Look through Autochangers first */
1065 foreach_res(changer, R_AUTOCHANGER) {
1066 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
1067 /* Find resource, and make sure we were able to open it */
1068 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1069 /* Try each device in this AutoChanger */
1070 foreach_alist(rctx.device, changer->device) {
1071 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
1072 stat = reserve_device(rctx);
1073 if (stat != 1) { /* try another device */
1077 if (rctx.store->append == SD_APPEND) {
1078 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1079 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1081 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1082 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1089 /* Now if requested look through regular devices */
1090 if (!rctx.autochanger_only) {
1091 foreach_res(rctx.device, R_DEVICE) {
1092 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
1093 /* Find resource, and make sure we were able to open it */
1094 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1095 stat = reserve_device(rctx);
1096 if (stat != 1) { /* try another device */
1100 if (rctx.store->append == SD_APPEND) {
1101 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1102 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1104 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1105 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1111 return -1; /* nothing found */
1115 * Try to reserve a specific device.
1117 * Returns: 1 -- OK, have DCR
1121 static int reserve_device(RCTX &rctx)
1125 const int name_len = MAX_NAME_LENGTH;
1127 /* Make sure MediaType is OK */
1128 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
1129 rctx.device->media_type, rctx.store->media_type);
1130 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1134 /* Make sure device exists -- i.e. we can stat() it */
1135 if (!rctx.device->dev) {
1136 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1138 if (!rctx.device->dev) {
1139 if (rctx.device->changer_res) {
1140 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1141 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1142 rctx.device->hdr.name, rctx.device_name);
1144 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1145 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1148 return -1; /* no use waiting */
1151 rctx.suitable_device = true;
1152 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1153 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1155 BSOCK *dir = rctx.jcr->dir_bsock;
1156 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1157 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1160 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1161 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1162 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1163 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1164 if (rctx.store->append == SD_APPEND) {
1165 Dmsg2(dbglvl, "call reserve for append: have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
1166 ok = reserve_device_for_append(dcr, rctx);
1171 rctx.jcr->dcr = dcr;
1172 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1173 dcr->dev->reserved_device,
1174 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1175 Dmsg3(dbglvl, "Vol=%s num_writers=%d, have_vol=%d\n",
1176 rctx.VolumeName, dcr->dev->num_writers, rctx.have_volume);
1177 if (rctx.have_volume) {
1178 Dmsg0(dbglvl, "Call reserve_volume\n");
1179 if (reserve_volume(dcr, rctx.VolumeName)) {
1180 Dmsg1(dbglvl, "Reserved vol=%s\n", rctx.VolumeName);
1182 Dmsg1(dbglvl, "Could not reserve vol=%s\n", rctx.VolumeName);
1186 dcr->any_volume = true;
1187 Dmsg0(dbglvl, "no vol, call find_next_appendable_vol.\n");
1188 if (dir_find_next_appendable_volume(dcr)) {
1189 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1190 rctx.have_volume = true;
1191 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
1193 Dmsg0(dbglvl, "No next volume found\n");
1194 rctx.have_volume = false;
1195 rctx.VolumeName[0] = 0;
1197 * If there is at least one volume that is valid and in use,
1198 * but we get here, check if we are running with prefers
1199 * non-mounted drives. In that case, we have selected a
1200 * non-used drive and our one and only volume is mounted
1201 * elsewhere, so we bail out and retry using that drive.
1203 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1204 rctx.PreferMountedVols = true;
1205 if (dcr->VolumeName[0]) {
1206 unreserve_device(dcr);
1211 * Note. Under some circumstances, the Director can hand us
1212 * a Volume name that is not the same as the one on the current
1213 * drive, and in that case, the call above to find the next
1214 * volume will fail because in attempting to reserve the Volume
1215 * the code will realize that we already have a tape mounted,
1216 * and it will fail. This *should* only happen if there are
1217 * writers, thus the following test. In that case, we simply
1218 * bail out, and continue waiting, rather than plunging on
1219 * and hoping that the operator can resolve the problem.
1221 if (dcr->dev->num_writers != 0) {
1222 if (dcr->VolumeName[0]) {
1223 unreserve_device(dcr);
1230 ok = reserve_device_for_read(dcr);
1232 rctx.jcr->read_dcr = dcr;
1233 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1234 dcr->dev->reserved_device,
1235 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1242 if (rctx.notify_dir) {
1244 BSOCK *dir = rctx.jcr->dir_bsock;
1245 pm_strcpy(dev_name, rctx.device->hdr.name);
1246 bash_spaces(dev_name);
1247 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1248 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1255 rctx.have_volume = false;
1256 rctx.VolumeName[0] = 0;
1257 Dmsg0(dbglvl, "Not OK.\n");
1262 * We "reserve" the drive by setting the ST_READ bit. No one else
1263 * should touch the drive until that is cleared.
1264 * This allows the DIR to "reserve" the device before actually
1267 static bool reserve_device_for_read(DCR *dcr)
1269 DEVICE *dev = dcr->dev;
1270 JCR *jcr = dcr->jcr;
1277 if (is_device_unmounted(dev)) {
1278 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
1279 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1280 jcr->JobId, dev->print_name());
1281 queue_reserve_message(jcr);
1285 if (dev->is_busy()) {
1286 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1288 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1289 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1290 jcr->JobId, dev->print_name());
1291 queue_reserve_message(jcr);
1295 dev->clear_append();
1298 dev->reserved_device++;
1299 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev);
1300 dcr->reserved_device = true;
1309 * We reserve the device for appending by incrementing the
1310 * reserved_device. We do virtually all the same work that
1311 * is done in acquire_device_for_append(), but we do
1312 * not attempt to mount the device. This routine allows
1313 * the DIR to reserve multiple devices before *really*
1314 * starting the job. It also permits the SD to refuse
1315 * certain devices (not up, ...).
1317 * Note, in reserving a device, if the device is for the
1318 * same pool and the same pool type, then it is acceptable.
1319 * The Media Type has already been checked. If we are
1320 * the first tor reserve the device, we put the pool
1321 * name and pool type in the device record.
1323 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1325 JCR *jcr = dcr->jcr;
1326 DEVICE *dev = dcr->dev;
1333 /* If device is being read, we cannot write it */
1334 if (dev->can_read()) {
1335 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1336 jcr->JobId, dev->print_name());
1337 Dmsg1(dbglvl, "%s", jcr->errmsg);
1338 queue_reserve_message(jcr);
1342 /* If device is unmounted, we are out of luck */
1343 if (is_device_unmounted(dev)) {
1344 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1345 jcr->JobId, dev->print_name());
1346 Dmsg1(dbglvl, "%s", jcr->errmsg);
1347 queue_reserve_message(jcr);
1351 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
1353 /* Now do detailed tests ... */
1354 if (can_reserve_drive(dcr, rctx) != 1) {
1355 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
1359 dev->reserved_device++;
1360 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device,
1361 dev->print_name(), dev);
1362 dcr->reserved_device = true;
1370 static int is_pool_ok(DCR *dcr)
1372 DEVICE *dev = dcr->dev;
1373 JCR *jcr = dcr->jcr;
1375 /* Now check if we want the same Pool and pool type */
1376 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1377 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1378 /* OK, compatible device */
1379 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1382 /* Drive Pool not suitable for us */
1383 Mmsg(jcr->errmsg, _(
1384 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1385 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1386 dev->reserved_device, dev->print_name());
1387 queue_reserve_message(jcr);
1388 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1389 dev->pool_name, dcr->pool_name);
1394 static bool is_max_jobs_ok(DCR *dcr)
1396 DEVICE *dev = dcr->dev;
1397 JCR *jcr = dcr->jcr;
1399 Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n",
1400 dcr->VolCatInfo.VolCatMaxJobs,
1401 dcr->VolCatInfo.VolCatJobs, dev->reserved_device,
1403 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1404 (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) {
1405 /* Max Job Vols depassed or already reserved */
1406 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1407 (uint32_t)jcr->JobId, dev->print_name());
1408 queue_reserve_message(jcr);
1409 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1410 return false; /* wait */
1416 * Returns: 1 if drive can be reserved
1417 * 0 if we should wait
1418 * -1 on error or impossibility
1420 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1422 DEVICE *dev = dcr->dev;
1423 JCR *jcr = dcr->jcr;
1425 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1426 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1427 rctx.autochanger_only, rctx.any_drive);
1429 /* Check for max jobs on this Volume */
1430 if (!is_max_jobs_ok(dcr)) {
1434 /* setting any_drive overrides PreferMountedVols flag */
1435 if (!rctx.any_drive) {
1437 * When PreferMountedVols is set, we keep track of the
1438 * drive in use that has the least number of writers, then if
1439 * no unmounted drive is found, we try that drive. This
1440 * helps spread the load to the least used drives.
1442 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1443 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
1444 dev->print_name(), rctx.low_use_drive->print_name());
1447 /* If he wants a free drive, but this one is busy, no go */
1448 if (!rctx.PreferMountedVols && dev->is_busy()) {
1449 /* Save least used drive */
1450 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1451 rctx.num_writers = dev->num_writers + dev->reserved_device;
1452 rctx.low_use_drive = dev;
1453 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
1454 dev->print_name(), rctx.num_writers);
1456 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->reserved_device);
1458 Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
1459 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1460 jcr->JobId, dev->print_name());
1461 queue_reserve_message(jcr);
1465 /* Check for prefer mounted volumes */
1466 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1467 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1468 jcr->JobId, dev->print_name());
1469 queue_reserve_message(jcr);
1470 Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
1471 return 0; /* No volume mounted */
1474 /* Check for exact Volume name match */
1475 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1478 if (rctx.exact_match && rctx.have_volume) {
1480 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1481 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1482 rctx.autochanger_only, rctx.any_drive);
1483 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1484 rctx.have_volume, dev->VolHdr.VolumeName,
1485 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1486 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1487 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1489 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1490 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1492 queue_reserve_message(jcr);
1493 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1494 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1497 if (is_volume_in_use(dcr)) {
1498 return 0; /* fail if volume on another drive */
1503 /* Check for unused autochanger drive */
1504 if (rctx.autochanger_only && !dev->is_busy() &&
1505 dev->VolHdr.VolumeName[0] == 0) {
1506 /* Device is available but not yet reserved, reserve it for us */
1507 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1508 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1509 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1510 return 1; /* reserve drive */
1514 * Handle the case that there are no writers
1516 if (dev->num_writers == 0) {
1517 /* Now check if there are any reservations on the drive */
1518 if (dev->reserved_device) {
1519 return is_pool_ok(dcr);
1520 } else if (dev->can_append()) {
1521 if (is_pool_ok(dcr)) {
1524 /* Changing pool, unload old tape if any in drive */
1525 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1526 unload_autochanger(dcr, 0);
1529 /* Device is available but not yet reserved, reserve it for us */
1530 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1531 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1532 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1533 return 1; /* reserve drive */
1537 * Check if the device is in append mode with writers (i.e.
1538 * available if pool is the same).
1540 if (dev->can_append() || dev->num_writers > 0) {
1541 return is_pool_ok(dcr);
1543 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1544 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1545 jcr->JobId, dev->print_name());
1546 queue_reserve_message(jcr);
1547 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1548 return -1; /* error, should not get here */
1550 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1551 jcr->JobId, dev->print_name());
1552 queue_reserve_message(jcr);
1553 Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1561 * Queue a reservation error or failure message for this jcr
1563 static void queue_reserve_message(JCR *jcr)
1571 msgs = jcr->reserve_msgs;
1576 * Look for duplicate message. If found, do
1579 for (i=msgs->size()-1; i >= 0; i--) {
1580 msg = (char *)msgs->get(i);
1584 /* Comparison based on 4 digit message number */
1585 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1589 /* Message unique, so insert it */
1590 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1597 * Send any reservation messages queued for this jcr
1599 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1606 msgs = jcr->reserve_msgs;
1607 if (!msgs || msgs->size() == 0) {
1610 for (i=msgs->size()-1; i >= 0; i--) {
1611 msg = (char *)msgs->get(i);
1613 sendit(" ", 3, arg);
1614 sendit(msg, strlen(msg), arg);
1625 * Pop and release any reservations messages
1627 static void pop_reserve_messages(JCR *jcr)
1633 msgs = jcr->reserve_msgs;
1637 while ((msg = (char *)msgs->pop())) {
1645 * Also called from acquire.c
1647 void release_reserve_messages(JCR *jcr)
1649 pop_reserve_messages(jcr);
1651 if (!jcr->reserve_msgs) {
1654 delete jcr->reserve_msgs;
1655 jcr->reserve_msgs = NULL;