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 Dmsg1(dbglvl, "=== OK, vol=%s on device. set not released.\n", VolumeName);
341 vol->released = false; /* retake vol if released previously */
342 goto get_out; /* Volume already on this device */
344 /* Don't release a volume if it is in use */
345 if (!vol->released) {
346 Dmsg1(dbglvl, "Cannot free vol=%s. It is not released.\n", vol->vol_name);
347 vol = NULL; /* vol in use */
350 Dmsg2(dbglvl, "reserve_vol free vol=%s at %p\n", vol->vol_name, vol->vol_name);
351 unload_autochanger(dcr, -1); /* unload the volume */
353 debug_list_volumes("reserve_vol free");
357 /* Create a new Volume entry */
358 nvol = new_vol_item(dcr, VolumeName);
361 * Now try to insert the new Volume
363 vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
365 Dmsg2(dbglvl, "Found vol=%s dev-same=%d\n", vol->vol_name, dev==vol->dev);
367 * At this point, a Volume with this name already is in the list,
368 * so we simply release our new Volume entry. Note, this should
369 * only happen if we are moving the volume from one drive to another.
371 Dmsg2(dbglvl, "reserve_vol free-tmp vol=%s at %p\n",
372 vol->vol_name, vol->vol_name);
374 * Clear dev pointer so that free_vol_item() doesn't
375 * take away our volume.
377 nvol->dev = NULL; /* don't zap dev entry */
380 /* Check if we are trying to use the Volume on a different drive */
381 if (dev != vol->dev) {
382 /* Caller wants to switch Volume to another device */
383 Dmsg2(dbglvl, "==== Swap from dev=%s to %s\n",
384 dev->print_name(), vol->dev->print_name());
385 switch_device(dcr, vol->dev);
387 bstrncpy(dcr->VolumeName, VolumeName, sizeof(dcr->VolumeName));
389 if (!vol->dev->is_busy()) {
390 /* OK to move it -- I'm not sure this will work */
391 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n", VolumeName,
392 vol->dev->print_name(), dev->print_name());
393 vol->dev->vol = NULL; /* take vol from old drive */
394 vol->dev->VolHdr.VolumeName[0] = 0;
395 vol->dev = dev; /* point vol at new drive */
396 dev->vol = vol; /* point dev at vol */
397 dev->VolHdr.VolumeName[0] = 0;
399 Dmsg3(dbglvl, "==== Swap not possible Vol busy vol=%s from dev=%s to %s\n",
400 VolumeName, vol->dev->print_name(), dev->print_name());
401 vol = NULL; /* device busy */
411 Dmsg1(dbglvl, "=== set not released. vol=%s\n", vol->vol_name);
412 vol->released = false;
414 debug_list_volumes("end new volume");
420 * Switch from current device to given device
423 void switch_device(DCR *dcr, DEVICE *dev)
425 // lock_reservations();
429 memcpy(&save_dcr, dcr, sizeof(save_dcr));
430 clean_device(dcr); /* clean up the dcr */
432 dcr->dev = dev; /* get new device pointer */
433 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
434 dcr->dev->print_name());
436 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
437 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
438 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
439 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
440 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
441 bstrncpy(dcr->dev_name, dev->dev_name, sizeof(dcr->dev_name));
443 dev->reserved_device++;
444 dcr->reserved_device = true;
450 * Search for a Volume name in the Volume list.
452 * Returns: VOLRES entry on success
453 * NULL if the Volume is not in the list
455 VOLRES *find_volume(DCR *dcr)
458 /* Do not lock reservations here */
460 vol.vol_name = bstrdup(dcr->VolumeName);
461 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
463 Dmsg2(dbglvl, "find_vol=%s found=%d\n", dcr->VolumeName, fvol!=NULL);
464 debug_list_volumes("find_volume");
470 * Remove any reservation from a drive and tell the system
471 * that the volume is unused at least by us.
473 void unreserve_device(DCR *dcr)
475 DEVICE *dev = dcr->dev;
476 if (dcr->reserved_device) {
477 dcr->reserved_device = false;
478 dev->reserved_device--;
479 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name());
480 dcr->reserved_device = false;
481 /* If we set read mode in reserving, remove it */
482 if (dev->can_read()) {
485 if (dev->num_writers < 0) {
486 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
487 dev->num_writers = 0;
489 if (dev->reserved_device == 0 && dev->num_writers == 0) {
496 * Free a Volume from the Volume list if it is no longer used
497 * Note, for tape drives we want to remember where the Volume
498 * was when last used, so rather than free the volume entry,
499 * we simply mark it "released" so when the drive is really
500 * needed for another volume, we can reuse it.
502 * Returns: true if the Volume found and "removed" from the list
503 * false if the Volume is not in the list or is in use
505 bool volume_unused(DCR *dcr)
507 DEVICE *dev = dcr->dev;
509 if (dev->vol == NULL) {
510 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
511 debug_list_volumes("null vol cannot unreserve_volume");
516 if (dev->is_busy()) {
517 Dmsg1(dbglvl, "vol_unused: busy on %s\n", dev->print_name());
518 debug_list_volumes("dev busy cannot unreserve_volume");
523 if (dev->num_writers > 0 || dev->reserved_device > 0) {
529 * If this is a tape, we do not free the volume, rather we wait
530 * until the autoloader unloads it, or until another tape is
531 * explicitly read in this drive. This allows the SD to remember
532 * where the tapes are or last were.
534 Dmsg3(dbglvl, "=== mark released vol=%s num_writers=%d dev_reserved=%d\n",
535 dev->vol->vol_name, dev->num_writers, dev->reserved_device);
536 dev->vol->released = true;
537 if (dev->is_tape()) { // || dev->is_autochanger()) {
541 * Note, this frees the volume reservation entry, but the
542 * file descriptor remains open with the OS.
544 return free_volume(dev);
549 * Unconditionally release the volume entry
551 bool free_volume(DEVICE *dev)
555 if (dev->vol == NULL) {
556 Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name());
562 vol_list->remove(vol);
563 Dmsg2(dbglvl, "=== free_volume %s dev=%s\n", vol->vol_name, dev->print_name());
565 debug_list_volumes("free_volume");
567 // return vol != NULL;
572 /* Create the Volume list */
573 void create_volume_list()
576 if (vol_list == NULL) {
577 vol_list = New(dlist(vol, &vol->link));
581 /* Release all Volumes from the list */
582 void free_volume_list()
589 foreach_dlist(vol, vol_list) {
591 Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name());
593 Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name);
596 vol->vol_name = NULL;
603 bool is_volume_in_use(DCR *dcr)
605 VOLRES *vol = find_volume(dcr);
607 Dmsg1(dbglvl, "Vol=%s not in use.\n", dcr->VolumeName);
608 return false; /* vol not in list */
610 ASSERT(vol->dev != NULL);
612 if (dcr->dev == vol->dev) { /* same device OK */
613 Dmsg1(dbglvl, "Vol=%s on same dev.\n", dcr->VolumeName);
616 Dmsg3(dbglvl, "Vol=%s on %s we have %s\n", dcr->VolumeName,
617 vol->dev->print_name(), dcr->dev->print_name());
619 if (!vol->dev->is_busy()) {
620 Dmsg2(dbglvl, "Vol=%s dev=%s not busy.\n", dcr->VolumeName, vol->dev->print_name());
623 Dmsg2(dbglvl, "Vol=%s dev=%s busy.\n", dcr->VolumeName, vol->dev->print_name());
625 Dmsg2(dbglvl, "Vol=%s in use by %s.\n", dcr->VolumeName, vol->dev->print_name());
631 * We get the following type of information:
633 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
637 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
641 static bool use_storage_cmd(JCR *jcr)
643 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
644 BSOCK *dir = jcr->dir_bsock;
652 memset(&rctx, 0, sizeof(RCTX));
655 * If there are multiple devices, the director sends us
656 * use_device for each device that it wants to use.
658 dirstore = New(alist(10, not_owned_by_alist));
659 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
661 Dmsg1(dbglvl, "<dird: %s", dir->msg);
662 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
663 media_type.c_str(), pool_name.c_str(),
664 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
669 jcr->write_store = dirstore;
671 jcr->read_store = dirstore;
673 rctx.append = append;
674 unbash_spaces(store_name);
675 unbash_spaces(media_type);
676 unbash_spaces(pool_name);
677 unbash_spaces(pool_type);
678 store = new DIRSTORE;
679 dirstore->append(store);
680 memset(store, 0, sizeof(DIRSTORE));
681 store->device = New(alist(10));
682 bstrncpy(store->name, store_name, sizeof(store->name));
683 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
684 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
685 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
686 store->append = append;
688 /* Now get all devices */
689 while (dir->recv() >= 0) {
690 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
691 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
695 unbash_spaces(dev_name);
696 store->device->append(bstrdup(dev_name.c_str()));
698 } while (ok && dir->recv() >= 0);
700 /* Developer debug code */
702 if (debug_level >= dbglvl) {
703 foreach_alist(store, dirstore) {
704 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
705 store->name, store->media_type, store->pool_name,
706 store->pool_type, store->append);
707 foreach_alist(device_name, store->device) {
708 Dmsg1(dbglvl, " Device=%s\n", device_name);
713 init_jcr_device_wait_timers(jcr);
714 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
716 BSOCK *dir = jcr->dir_bsock;
717 dir->fsend(_("3939 Could not get dcr\n"));
718 Dmsg1(dbglvl, ">dird: %s", dir->msg);
722 * At this point, we have a list of all the Director's Storage
723 * resources indicated for this Job, which include Pool, PoolType,
724 * storage name, and Media type.
725 * Then for each of the Storage resources, we have a list of
726 * device names that were given.
728 * Wiffle through them and find one that can do the backup.
731 int wait_for_device_retries = 0;
734 rctx.notify_dir = true;
737 for ( ; !fail && !job_canceled(jcr); ) {
738 pop_reserve_messages(jcr);
739 rctx.suitable_device = false;
740 rctx.have_volume = false;
741 rctx.VolumeName[0] = 0;
742 rctx.any_drive = false;
743 if (!jcr->PreferMountedVols) {
745 * Here we try to find a drive that is not used.
746 * This will maximize the use of available drives.
749 rctx.num_writers = 20000000; /* start with impossible number */
750 rctx.low_use_drive = NULL;
751 rctx.PreferMountedVols = false;
752 rctx.exact_match = false;
753 rctx.autochanger_only = true;
754 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
755 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
756 rctx.autochanger_only, rctx.any_drive);
757 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
760 /* Look through all drives possibly for low_use drive */
761 if (rctx.low_use_drive) {
762 rctx.try_low_use_drive = true;
763 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
766 rctx.try_low_use_drive = false;
768 rctx.autochanger_only = false;
769 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
770 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
771 rctx.autochanger_only, rctx.any_drive);
772 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
777 * Now we look for a drive that may or may not be in
780 /* Look for an exact Volume match all drives */
781 rctx.PreferMountedVols = true;
782 rctx.exact_match = true;
783 rctx.autochanger_only = false;
784 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
785 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
786 rctx.autochanger_only, rctx.any_drive);
787 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
790 /* Look for any mounted drive */
791 rctx.exact_match = false;
792 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
793 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
794 rctx.autochanger_only, rctx.any_drive);
795 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
799 rctx.any_drive = true;
800 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
801 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
802 rctx.autochanger_only, rctx.any_drive);
803 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
806 /* Keep reservations locked *except* during wait_for_device() */
807 unlock_reservations();
809 * The idea of looping on repeat a few times it to ensure
810 * that if there is some subtle timing problem between two
811 * jobs, we will simply try again, and most likely succeed.
812 * This can happen if one job reserves a drive or finishes using
813 * a drive at the same time a second job wants it.
815 if (repeat++ > 1) { /* try algorithm 3 times */
816 bmicrosleep(30, 0); /* wait a bit */
817 Dmsg0(dbglvl, "repeat reserve algorithm\n");
818 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
819 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
823 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
825 unlock_reservations();
828 * If we get here, there are no suitable devices available, which
829 * means nothing configured. If a device is suitable but busy
830 * with another Volume, we will not come here.
832 unbash_spaces(dir->msg);
833 pm_strcpy(jcr->errmsg, dir->msg);
834 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
835 Jmsg(jcr, M_FATAL, 0, _("\n"
836 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
837 dev_name.c_str(), media_type.c_str());
838 dir->fsend(NO_device, dev_name.c_str());
840 Dmsg1(dbglvl, ">dird: %s", dir->msg);
843 unbash_spaces(dir->msg);
844 pm_strcpy(jcr->errmsg, dir->msg);
845 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
846 dir->fsend(BAD_use, jcr->errmsg);
847 Dmsg1(dbglvl, ">dird: %s", dir->msg);
850 release_reserve_messages(jcr);
856 * Walk through the autochanger resources and check if
857 * the volume is in one of them.
859 * Returns: true if volume is in device
862 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
864 AUTOCHANGER *changer = vol->dev->device->changer_res;
866 /* Find resource, and make sure we were able to open it */
867 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
868 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
871 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
876 * Search for a device suitable for this job.
877 * Note, this routine sets sets rctx.suitable_device if any
878 * device exists within the SD. The device may not be actually
880 * It also returns if it finds a useable device.
882 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
891 dirstore = jcr->write_store;
893 dirstore = jcr->read_store;
895 Dmsg4(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
896 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
897 rctx.autochanger_only);
900 * If the appropriate conditions of this if are met, namely that
901 * we are appending and the user wants mounted drive (or we
902 * force try a mounted drive because they are all busy), we
903 * start by looking at all the Volumes in the volume list.
905 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
906 dlist *temp_vol_list, *save_vol_list;
909 Dmsg0(dbglvl, "lock volumes\n");
912 * Create a temporary copy of the volume list. We do this,
913 * to avoid having the volume list locked during the
914 * call to reserve_device(), which would cause a deadlock.
915 * Note, we may want to add an update counter on the vol_list
916 * so that if it is modified while we are traversing the copy
917 * we can take note and act accordingly (probably redo the
918 * search at least a few times).
920 Dmsg0(dbglvl, "duplicate vol list\n");
921 temp_vol_list = New(dlist(vol, &vol->link));
922 foreach_dlist(vol, vol_list) {
924 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
925 memset(tvol, 0, sizeof(VOLRES));
926 tvol->vol_name = bstrdup(vol->vol_name);
927 tvol->dev = vol->dev;
928 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
930 tvol->dev = NULL; /* don't zap dev entry */
932 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
933 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
936 Dmsg0(dbglvl, "unlock volumes\n");
939 /* Look through reserved volumes for one we can use */
940 Dmsg0(dbglvl, "look for vol in vol list\n");
941 foreach_dlist(vol, temp_vol_list) {
943 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
946 /* Check with Director if this Volume is OK */
947 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
948 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
952 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
953 foreach_alist(store, dirstore) {
956 foreach_alist(device_name, store->device) {
957 /* Found a device, try to use it */
958 rctx.device_name = device_name;
959 rctx.device = vol->dev->device;
961 if (vol->dev->is_autochanger()) {
962 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
963 if (!is_vol_in_autochanger(rctx, vol)) {
966 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
967 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
968 vol->dev->device->hdr.name, device_name);
972 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
973 rctx.have_volume = true;
974 /* Try reserving this device and volume */
975 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
976 stat = reserve_device(rctx);
977 if (stat == 1) { /* found available device */
978 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
981 } else if (stat == 0) { /* device busy */
982 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
984 /* otherwise error */
985 Dmsg0(dbglvl, "No suitable device found.\n");
987 rctx.have_volume = false;
988 rctx.VolumeName[0] = 0;
997 } /* end for loop over reserved volumes */
999 Dmsg0(dbglvl, "lock volumes\n");
1001 save_vol_list = vol_list;
1002 vol_list = temp_vol_list;
1003 free_volume_list(); /* release temp_vol_list */
1004 vol_list = save_vol_list;
1005 Dmsg0(dbglvl, "deleted temp vol list\n");
1006 Dmsg0(dbglvl, "unlock volumes\n");
1008 debug_list_volumes("=== After free temp table\n");
1011 Dmsg1(dbglvl, "Usable dev found. Vol=%s from in-use vols list\n", rctx.VolumeName);
1016 * No reserved volume we can use, so now search for an available device.
1018 * For each storage device that the user specified, we
1019 * search and see if there is a resource for that device.
1021 foreach_alist(store, dirstore) {
1023 foreach_alist(device_name, store->device) {
1025 rctx.device_name = device_name;
1026 stat = search_res_for_device(rctx);
1027 if (stat == 1) { /* found available device */
1028 Dmsg1(dbglvl, "available device found=%s\n", device_name);
1031 } else if (stat == 0) { /* device busy */
1032 Dmsg1(dbglvl, "No usable device=%s, busy: not use\n", device_name);
1034 /* otherwise error */
1035 Dmsg0(dbglvl, "No usable device found.\n");
1043 Dmsg1(dbglvl, "Usable dev found. Vol=%s\n", rctx.VolumeName);
1049 * Search for a particular storage device with particular storage
1050 * characteristics (MediaType).
1052 int search_res_for_device(RCTX &rctx)
1054 AUTOCHANGER *changer;
1057 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
1058 /* Look through Autochangers first */
1059 foreach_res(changer, R_AUTOCHANGER) {
1060 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
1061 /* Find resource, and make sure we were able to open it */
1062 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1063 /* Try each device in this AutoChanger */
1064 foreach_alist(rctx.device, changer->device) {
1065 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
1066 stat = reserve_device(rctx);
1067 if (stat != 1) { /* try another device */
1071 if (rctx.store->append == SD_APPEND) {
1072 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1073 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1075 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1076 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1083 /* Now if requested look through regular devices */
1084 if (!rctx.autochanger_only) {
1085 foreach_res(rctx.device, R_DEVICE) {
1086 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
1087 /* Find resource, and make sure we were able to open it */
1088 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1089 stat = reserve_device(rctx);
1090 if (stat != 1) { /* try another device */
1094 if (rctx.store->append == SD_APPEND) {
1095 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1096 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1098 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1099 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1105 return -1; /* nothing found */
1109 * Try to reserve a specific device.
1111 * Returns: 1 -- OK, have DCR
1115 static int reserve_device(RCTX &rctx)
1119 const int name_len = MAX_NAME_LENGTH;
1121 /* Make sure MediaType is OK */
1122 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
1123 rctx.device->media_type, rctx.store->media_type);
1124 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1128 /* Make sure device exists -- i.e. we can stat() it */
1129 if (!rctx.device->dev) {
1130 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1132 if (!rctx.device->dev) {
1133 if (rctx.device->changer_res) {
1134 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1135 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1136 rctx.device->hdr.name, rctx.device_name);
1138 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1139 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1142 return -1; /* no use waiting */
1145 rctx.suitable_device = true;
1146 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1147 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1149 BSOCK *dir = rctx.jcr->dir_bsock;
1150 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1151 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1154 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1155 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1156 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1157 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1158 if (rctx.store->append == SD_APPEND) {
1159 Dmsg2(dbglvl, "call reserve for append: have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
1160 ok = reserve_device_for_append(dcr, rctx);
1165 rctx.jcr->dcr = dcr;
1166 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1167 dcr->dev->reserved_device,
1168 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1169 Dmsg3(dbglvl, "Vol=%s num_writers=%d, have_vol=%d\n",
1170 rctx.VolumeName, dcr->dev->num_writers, rctx.have_volume);
1171 if (rctx.have_volume) {
1172 Dmsg0(dbglvl, "Call reserve_volume\n");
1173 if (reserve_volume(dcr, rctx.VolumeName)) {
1174 Dmsg1(dbglvl, "Reserved vol=%s\n", rctx.VolumeName);
1176 Dmsg1(dbglvl, "Could not reserve vol=%s\n", rctx.VolumeName);
1180 dcr->any_volume = true;
1181 Dmsg0(dbglvl, "no vol, call find_next_appendable_vol.\n");
1182 if (dir_find_next_appendable_volume(dcr)) {
1183 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1184 rctx.have_volume = true;
1185 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
1187 Dmsg0(dbglvl, "No next volume found\n");
1188 rctx.have_volume = false;
1189 rctx.VolumeName[0] = 0;
1191 * If there is at least one volume that is valid and in use,
1192 * but we get here, check if we are running with prefers
1193 * non-mounted drives. In that case, we have selected a
1194 * non-used drive and our one and only volume is mounted
1195 * elsewhere, so we bail out and retry using that drive.
1197 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1198 rctx.PreferMountedVols = true;
1199 if (dcr->VolumeName[0]) {
1200 unreserve_device(dcr);
1205 * Note. Under some circumstances, the Director can hand us
1206 * a Volume name that is not the same as the one on the current
1207 * drive, and in that case, the call above to find the next
1208 * volume will fail because in attempting to reserve the Volume
1209 * the code will realize that we already have a tape mounted,
1210 * and it will fail. This *should* only happen if there are
1211 * writers, thus the following test. In that case, we simply
1212 * bail out, and continue waiting, rather than plunging on
1213 * and hoping that the operator can resolve the problem.
1215 if (dcr->dev->num_writers != 0) {
1216 if (dcr->VolumeName[0]) {
1217 unreserve_device(dcr);
1224 ok = reserve_device_for_read(dcr);
1226 rctx.jcr->read_dcr = dcr;
1227 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1228 dcr->dev->reserved_device,
1229 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1236 if (rctx.notify_dir) {
1238 BSOCK *dir = rctx.jcr->dir_bsock;
1239 pm_strcpy(dev_name, rctx.device->hdr.name);
1240 bash_spaces(dev_name);
1241 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1242 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1249 rctx.have_volume = false;
1250 rctx.VolumeName[0] = 0;
1251 Dmsg0(dbglvl, "Not OK.\n");
1256 * We "reserve" the drive by setting the ST_READ bit. No one else
1257 * should touch the drive until that is cleared.
1258 * This allows the DIR to "reserve" the device before actually
1261 static bool reserve_device_for_read(DCR *dcr)
1263 DEVICE *dev = dcr->dev;
1264 JCR *jcr = dcr->jcr;
1271 if (is_device_unmounted(dev)) {
1272 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
1273 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1274 jcr->JobId, dev->print_name());
1275 queue_reserve_message(jcr);
1279 if (dev->is_busy()) {
1280 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1282 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1283 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1284 jcr->JobId, dev->print_name());
1285 queue_reserve_message(jcr);
1289 dev->clear_append();
1292 dev->reserved_device++;
1293 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev);
1294 dcr->reserved_device = true;
1303 * We reserve the device for appending by incrementing the
1304 * reserved_device. We do virtually all the same work that
1305 * is done in acquire_device_for_append(), but we do
1306 * not attempt to mount the device. This routine allows
1307 * the DIR to reserve multiple devices before *really*
1308 * starting the job. It also permits the SD to refuse
1309 * certain devices (not up, ...).
1311 * Note, in reserving a device, if the device is for the
1312 * same pool and the same pool type, then it is acceptable.
1313 * The Media Type has already been checked. If we are
1314 * the first tor reserve the device, we put the pool
1315 * name and pool type in the device record.
1317 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1319 JCR *jcr = dcr->jcr;
1320 DEVICE *dev = dcr->dev;
1327 /* If device is being read, we cannot write it */
1328 if (dev->can_read()) {
1329 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1330 jcr->JobId, dev->print_name());
1331 Dmsg1(dbglvl, "%s", jcr->errmsg);
1332 queue_reserve_message(jcr);
1336 /* If device is unmounted, we are out of luck */
1337 if (is_device_unmounted(dev)) {
1338 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1339 jcr->JobId, dev->print_name());
1340 Dmsg1(dbglvl, "%s", jcr->errmsg);
1341 queue_reserve_message(jcr);
1345 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
1347 /* Now do detailed tests ... */
1348 if (can_reserve_drive(dcr, rctx) != 1) {
1349 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
1353 dev->reserved_device++;
1354 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device,
1355 dev->print_name(), dev);
1356 dcr->reserved_device = true;
1364 static int is_pool_ok(DCR *dcr)
1366 DEVICE *dev = dcr->dev;
1367 JCR *jcr = dcr->jcr;
1369 /* Now check if we want the same Pool and pool type */
1370 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1371 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1372 /* OK, compatible device */
1373 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1376 /* Drive Pool not suitable for us */
1377 Mmsg(jcr->errmsg, _(
1378 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1379 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1380 dev->reserved_device, dev->print_name());
1381 queue_reserve_message(jcr);
1382 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1383 dev->pool_name, dcr->pool_name);
1388 static bool is_max_jobs_ok(DCR *dcr)
1390 DEVICE *dev = dcr->dev;
1391 JCR *jcr = dcr->jcr;
1393 Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n",
1394 dcr->VolCatInfo.VolCatMaxJobs,
1395 dcr->VolCatInfo.VolCatJobs, dev->reserved_device,
1397 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1398 (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) {
1399 /* Max Job Vols depassed or already reserved */
1400 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1401 (uint32_t)jcr->JobId, dev->print_name());
1402 queue_reserve_message(jcr);
1403 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1404 return false; /* wait */
1410 * Returns: 1 if drive can be reserved
1411 * 0 if we should wait
1412 * -1 on error or impossibility
1414 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1416 DEVICE *dev = dcr->dev;
1417 JCR *jcr = dcr->jcr;
1419 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1420 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1421 rctx.autochanger_only, rctx.any_drive);
1423 /* Check for max jobs on this Volume */
1424 if (!is_max_jobs_ok(dcr)) {
1428 /* setting any_drive overrides PreferMountedVols flag */
1429 if (!rctx.any_drive) {
1431 * When PreferMountedVols is set, we keep track of the
1432 * drive in use that has the least number of writers, then if
1433 * no unmounted drive is found, we try that drive. This
1434 * helps spread the load to the least used drives.
1436 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1437 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
1438 dev->print_name(), rctx.low_use_drive->print_name());
1441 /* If he wants a free drive, but this one is busy, no go */
1442 if (!rctx.PreferMountedVols && dev->is_busy()) {
1443 /* Save least used drive */
1444 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1445 rctx.num_writers = dev->num_writers + dev->reserved_device;
1446 rctx.low_use_drive = dev;
1447 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
1448 dev->print_name(), rctx.num_writers);
1450 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->reserved_device);
1452 Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
1453 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1454 jcr->JobId, dev->print_name());
1455 queue_reserve_message(jcr);
1459 /* Check for prefer mounted volumes */
1460 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1461 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1462 jcr->JobId, dev->print_name());
1463 queue_reserve_message(jcr);
1464 Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
1465 return 0; /* No volume mounted */
1468 /* Check for exact Volume name match */
1469 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1472 if (rctx.exact_match && rctx.have_volume) {
1474 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1475 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1476 rctx.autochanger_only, rctx.any_drive);
1477 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1478 rctx.have_volume, dev->VolHdr.VolumeName,
1479 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1480 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1481 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1483 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1484 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1486 queue_reserve_message(jcr);
1487 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1488 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1491 if (is_volume_in_use(dcr)) {
1492 return 0; /* fail if volume on another drive */
1497 /* Check for unused autochanger drive */
1498 if (rctx.autochanger_only && !dev->is_busy() &&
1499 dev->VolHdr.VolumeName[0] == 0) {
1500 /* Device is available but not yet reserved, reserve it for us */
1501 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1502 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1503 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1504 return 1; /* reserve drive */
1508 * Handle the case that there are no writers
1510 if (dev->num_writers == 0) {
1511 /* Now check if there are any reservations on the drive */
1512 if (dev->reserved_device) {
1513 return is_pool_ok(dcr);
1514 } else if (dev->can_append()) {
1515 if (is_pool_ok(dcr)) {
1518 /* Changing pool, unload old tape if any in drive */
1519 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1520 unload_autochanger(dcr, 0);
1523 /* Device is available but not yet reserved, reserve it for us */
1524 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1525 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1526 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1527 return 1; /* reserve drive */
1531 * Check if the device is in append mode with writers (i.e.
1532 * available if pool is the same).
1534 if (dev->can_append() || dev->num_writers > 0) {
1535 return is_pool_ok(dcr);
1537 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1538 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1539 jcr->JobId, dev->print_name());
1540 queue_reserve_message(jcr);
1541 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1542 return -1; /* error, should not get here */
1544 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1545 jcr->JobId, dev->print_name());
1546 queue_reserve_message(jcr);
1547 Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1555 * Queue a reservation error or failure message for this jcr
1557 static void queue_reserve_message(JCR *jcr)
1565 msgs = jcr->reserve_msgs;
1570 * Look for duplicate message. If found, do
1573 for (i=msgs->size()-1; i >= 0; i--) {
1574 msg = (char *)msgs->get(i);
1578 /* Comparison based on 4 digit message number */
1579 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1583 /* Message unique, so insert it */
1584 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1591 * Send any reservation messages queued for this jcr
1593 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1600 msgs = jcr->reserve_msgs;
1601 if (!msgs || msgs->size() == 0) {
1604 for (i=msgs->size()-1; i >= 0; i--) {
1605 msg = (char *)msgs->get(i);
1607 sendit(" ", 3, arg);
1608 sendit(msg, strlen(msg), arg);
1619 * Pop and release any reservations messages
1621 static void pop_reserve_messages(JCR *jcr)
1627 msgs = jcr->reserve_msgs;
1631 while ((msg = (char *)msgs->pop())) {
1639 * Also called from acquire.c
1641 void release_reserve_messages(JCR *jcr)
1643 pop_reserve_messages(jcr);
1645 if (!jcr->reserve_msgs) {
1648 delete jcr->reserve_msgs;
1649 jcr->reserve_msgs = NULL;