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 *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 switch_device(dcr, vol->dev);
386 if (!vol->dev->is_busy()) {
387 /* OK to move it -- I'm not sure this will work */
388 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n", VolumeName,
389 vol->dev->print_name(), dev->print_name());
390 vol->dev->vol = NULL; /* take vol from old drive */
391 vol->dev->VolHdr.VolumeName[0] = 0;
392 vol->dev = dev; /* point vol at new drive */
393 dev->vol = vol; /* point dev at vol */
394 dev->VolHdr.VolumeName[0] = 0;
396 Dmsg3(dbglvl, "==== Swap not possible Vol busy vol=%s from dev=%s to %s\n",
397 VolumeName, vol->dev->print_name(), dev->print_name());
398 vol = NULL; /* device busy */
408 Dmsg1(dbglvl, "=== set not released. vol=%s\n", vol->vol_name);
409 vol->released = false;
411 debug_list_volumes("end new volume");
417 * Switch from current device to given device
420 void switch_device(DCR *dcr, DEVICE *dev)
422 // lock_reservations();
426 memcpy(&save_dcr, dcr, sizeof(save_dcr));
427 clean_device(dcr); /* clean up the dcr */
429 dcr->dev = dev; /* get new device pointer */
430 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
431 dcr->dev->print_name());
433 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
434 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
435 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
436 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
437 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
438 bstrncpy(dcr->dev_name, save_dcr.dev_name, sizeof(dcr->dev_name));
440 dev->reserved_device++;
441 dcr->reserved_device = true;
447 * Search for a Volume name in the Volume list.
449 * Returns: VOLRES entry on success
450 * NULL if the Volume is not in the list
452 VOLRES *find_volume(DCR *dcr)
455 /* Do not lock reservations here */
457 vol.vol_name = bstrdup(dcr->VolumeName);
458 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
460 Dmsg2(dbglvl, "find_vol=%s found=%d\n", dcr->VolumeName, fvol!=NULL);
461 debug_list_volumes("find_volume");
467 * Remove any reservation from a drive and tell the system
468 * that the volume is unused at least by us.
470 void unreserve_device(DCR *dcr)
472 DEVICE *dev = dcr->dev;
473 if (dcr->reserved_device) {
474 dcr->reserved_device = false;
475 dev->reserved_device--;
476 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name());
477 dcr->reserved_device = false;
478 /* If we set read mode in reserving, remove it */
479 if (dev->can_read()) {
482 if (dev->num_writers < 0) {
483 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
484 dev->num_writers = 0;
486 if (dev->reserved_device == 0 && dev->num_writers == 0) {
493 * Free a Volume from the Volume list if it is no longer used
494 * Note, for tape drives we want to remember where the Volume
495 * was when last used, so rather than free the volume entry,
496 * we simply mark it "released" so when the drive is really
497 * needed for another volume, we can reuse it.
499 * Returns: true if the Volume found and "removed" from the list
500 * false if the Volume is not in the list or is in use
502 bool volume_unused(DCR *dcr)
504 DEVICE *dev = dcr->dev;
506 if (dev->vol == NULL) {
507 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
508 debug_list_volumes("null vol cannot unreserve_volume");
513 if (dev->is_busy()) {
514 Dmsg1(dbglvl, "vol_unused: busy on %s\n", dev->print_name());
515 debug_list_volumes("dev busy cannot unreserve_volume");
520 if (dev->num_writers > 0 || dev->reserved_device > 0) {
526 * If this is a tape, we do not free the volume, rather we wait
527 * until the autoloader unloads it, or until another tape is
528 * explicitly read in this drive. This allows the SD to remember
529 * where the tapes are or last were.
531 Dmsg3(dbglvl, "=== mark released vol=%s num_writers=%d reserved=%d\n",
532 dev->vol->vol_name, dev->num_writers, dev->reserved_device);
533 dev->vol->released = true;
534 if (dev->is_tape()) { // || dev->is_autochanger()) {
538 * Note, this frees the volume reservation entry, but the
539 * file descriptor remains open with the OS.
541 return free_volume(dev);
546 * Unconditionally release the volume entry
548 bool free_volume(DEVICE *dev)
552 if (dev->vol == NULL) {
553 Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name());
559 vol_list->remove(vol);
560 Dmsg2(dbglvl, "=== free_volume %s dev=%s\n", vol->vol_name, dev->print_name());
562 debug_list_volumes("free_volume");
568 /* Create the Volume list */
569 void create_volume_list()
572 if (vol_list == NULL) {
573 vol_list = New(dlist(vol, &vol->link));
577 /* Release all Volumes from the list */
578 void free_volume_list()
585 foreach_dlist(vol, vol_list) {
587 Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name());
589 Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name);
592 vol->vol_name = NULL;
599 bool is_volume_in_use(DCR *dcr)
601 VOLRES *vol = find_volume(dcr);
603 Dmsg1(dbglvl, "Vol=%s not in use.\n", dcr->VolumeName);
604 return false; /* vol not in list */
606 ASSERT(vol->dev != NULL);
608 if (dcr->dev == vol->dev) { /* same device OK */
609 Dmsg1(dbglvl, "Vol=%s on same dev.\n", dcr->VolumeName);
612 Dmsg3(dbglvl, "Vol=%s on %s we have %s\n", dcr->VolumeName,
613 vol->dev->print_name(), dcr->dev->print_name());
615 if (!vol->dev->is_busy()) {
616 Dmsg2(dbglvl, "Vol=%s dev=%s not busy.\n", dcr->VolumeName, vol->dev->print_name());
619 Dmsg2(dbglvl, "Vol=%s dev=%s busy.\n", dcr->VolumeName, vol->dev->print_name());
621 Dmsg2(dbglvl, "Vol=%s in use by %s.\n", dcr->VolumeName, vol->dev->print_name());
627 * We get the following type of information:
629 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
633 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
637 static bool use_storage_cmd(JCR *jcr)
639 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
640 BSOCK *dir = jcr->dir_bsock;
648 memset(&rctx, 0, sizeof(RCTX));
651 * If there are multiple devices, the director sends us
652 * use_device for each device that it wants to use.
654 dirstore = New(alist(10, not_owned_by_alist));
655 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
657 Dmsg1(dbglvl, "<dird: %s", dir->msg);
658 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
659 media_type.c_str(), pool_name.c_str(),
660 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
665 jcr->write_store = dirstore;
667 jcr->read_store = dirstore;
669 rctx.append = append;
670 unbash_spaces(store_name);
671 unbash_spaces(media_type);
672 unbash_spaces(pool_name);
673 unbash_spaces(pool_type);
674 store = new DIRSTORE;
675 dirstore->append(store);
676 memset(store, 0, sizeof(DIRSTORE));
677 store->device = New(alist(10));
678 bstrncpy(store->name, store_name, sizeof(store->name));
679 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
680 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
681 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
682 store->append = append;
684 /* Now get all devices */
685 while (dir->recv() >= 0) {
686 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
687 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
691 unbash_spaces(dev_name);
692 store->device->append(bstrdup(dev_name.c_str()));
694 } while (ok && dir->recv() >= 0);
696 /* Developer debug code */
698 if (debug_level >= dbglvl) {
699 foreach_alist(store, dirstore) {
700 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
701 store->name, store->media_type, store->pool_name,
702 store->pool_type, store->append);
703 foreach_alist(device_name, store->device) {
704 Dmsg1(dbglvl, " Device=%s\n", device_name);
709 init_jcr_device_wait_timers(jcr);
710 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
712 BSOCK *dir = jcr->dir_bsock;
713 dir->fsend(_("3939 Could not get dcr\n"));
714 Dmsg1(dbglvl, ">dird: %s", dir->msg);
718 * At this point, we have a list of all the Director's Storage
719 * resources indicated for this Job, which include Pool, PoolType,
720 * storage name, and Media type.
721 * Then for each of the Storage resources, we have a list of
722 * device names that were given.
724 * Wiffle through them and find one that can do the backup.
727 int wait_for_device_retries = 0;
730 rctx.notify_dir = true;
733 for ( ; !fail && !job_canceled(jcr); ) {
734 pop_reserve_messages(jcr);
735 rctx.suitable_device = false;
736 rctx.have_volume = false;
737 rctx.VolumeName[0] = 0;
738 rctx.any_drive = false;
739 if (!jcr->PreferMountedVols) {
741 * Here we try to find a drive that is not used.
742 * This will maximize the use of available drives.
745 rctx.num_writers = 20000000; /* start with impossible number */
746 rctx.low_use_drive = NULL;
747 rctx.PreferMountedVols = false;
748 rctx.exact_match = false;
749 rctx.autochanger_only = true;
750 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
751 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
752 rctx.autochanger_only, rctx.any_drive);
753 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
756 /* Look through all drives possibly for low_use drive */
757 if (rctx.low_use_drive) {
758 rctx.try_low_use_drive = true;
759 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
762 rctx.try_low_use_drive = false;
764 rctx.autochanger_only = false;
765 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
766 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
767 rctx.autochanger_only, rctx.any_drive);
768 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
773 * Now we look for a drive that may or may not be in
776 /* Look for an exact Volume match all drives */
777 rctx.PreferMountedVols = true;
778 rctx.exact_match = true;
779 rctx.autochanger_only = false;
780 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
781 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
782 rctx.autochanger_only, rctx.any_drive);
783 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
786 /* Look for any mounted drive */
787 rctx.exact_match = 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))) {
795 rctx.any_drive = true;
796 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
797 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
798 rctx.autochanger_only, rctx.any_drive);
799 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
802 /* Keep reservations locked *except* during wait_for_device() */
803 unlock_reservations();
805 * The idea of looping on repeat a few times it to ensure
806 * that if there is some subtle timing problem between two
807 * jobs, we will simply try again, and most likely succeed.
808 * This can happen if one job reserves a drive or finishes using
809 * a drive at the same time a second job wants it.
811 if (repeat++ > 1) { /* try algorithm 3 times */
812 bmicrosleep(30, 0); /* wait a bit */
813 Dmsg0(dbglvl, "repeat reserve algorithm\n");
814 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
815 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
819 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
821 unlock_reservations();
824 * If we get here, there are no suitable devices available, which
825 * means nothing configured. If a device is suitable but busy
826 * with another Volume, we will not come here.
828 unbash_spaces(dir->msg);
829 pm_strcpy(jcr->errmsg, dir->msg);
830 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
831 Jmsg(jcr, M_FATAL, 0, _("\n"
832 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
833 dev_name.c_str(), media_type.c_str());
834 dir->fsend(NO_device, dev_name.c_str());
836 Dmsg1(dbglvl, ">dird: %s", dir->msg);
839 unbash_spaces(dir->msg);
840 pm_strcpy(jcr->errmsg, dir->msg);
841 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
842 dir->fsend(BAD_use, jcr->errmsg);
843 Dmsg1(dbglvl, ">dird: %s", dir->msg);
846 release_reserve_messages(jcr);
852 * Walk through the autochanger resources and check if
853 * the volume is in one of them.
855 * Returns: true if volume is in device
858 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
860 AUTOCHANGER *changer = vol->dev->device->changer_res;
862 /* Find resource, and make sure we were able to open it */
863 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
864 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
867 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
872 * Search for a device suitable for this job.
874 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
883 dirstore = jcr->write_store;
885 dirstore = jcr->read_store;
887 Dmsg4(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
888 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
889 rctx.autochanger_only);
892 * If the appropriate conditions of this if are met, namely that
893 * we are appending and the user wants mounted drive (or we
894 * force try a mounted drive because they are all busy), we
895 * start by looking at all the Volumes in the volume list.
897 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
898 dlist *temp_vol_list, *save_vol_list;
901 Dmsg0(dbglvl, "lock volumes\n");
904 * Create a temporary copy of the volume list. We do this,
905 * to avoid having the volume list locked during the
906 * call to reserve_device(), which would cause a deadlock.
907 * Note, we may want to add an update counter on the vol_list
908 * so that if it is modified while we are traversing the copy
909 * we can take note and act accordingly (probably redo the
910 * search at least a few times).
912 Dmsg0(dbglvl, "duplicate vol list\n");
913 temp_vol_list = New(dlist(vol, &vol->link));
914 foreach_dlist(vol, vol_list) {
916 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
917 memset(tvol, 0, sizeof(VOLRES));
918 tvol->vol_name = bstrdup(vol->vol_name);
919 tvol->dev = vol->dev;
920 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
922 tvol->dev = NULL; /* don't zap dev entry */
924 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
925 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
928 Dmsg0(dbglvl, "unlock volumes\n");
931 /* Look through reserved volumes for one we can use */
932 Dmsg0(dbglvl, "look for vol in vol list\n");
933 foreach_dlist(vol, temp_vol_list) {
935 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
938 /* Check with Director if this Volume is OK */
939 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
940 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
944 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
945 foreach_alist(store, dirstore) {
948 foreach_alist(device_name, store->device) {
949 /* Found a device, try to use it */
950 rctx.device_name = device_name;
951 rctx.device = vol->dev->device;
953 if (vol->dev->is_autochanger()) {
954 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
955 if (!is_vol_in_autochanger(rctx, vol)) {
958 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
959 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
960 vol->dev->device->hdr.name, device_name);
964 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
965 rctx.have_volume = true;
966 /* Try reserving this device and volume */
967 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
968 stat = reserve_device(rctx);
969 if (stat == 1) { /* found available device */
970 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
973 } else if (stat == 0) { /* device busy */
974 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
976 /* otherwise error */
977 Dmsg0(dbglvl, "No suitable device found.\n");
979 rctx.have_volume = false;
980 rctx.VolumeName[0] = 0;
989 } /* end for loop over reserved volumes */
991 Dmsg0(dbglvl, "lock volumes\n");
993 save_vol_list = vol_list;
994 vol_list = temp_vol_list;
995 free_volume_list(); /* release temp_vol_list */
996 vol_list = save_vol_list;
997 Dmsg0(dbglvl, "deleted temp vol list\n");
998 Dmsg0(dbglvl, "unlock volumes\n");
1000 debug_list_volumes("=== After free temp table\n");
1003 Dmsg1(dbglvl, "got vol %s from in-use vols list\n", rctx.VolumeName);
1008 * No reserved volume we can use, so now search for an available device.
1010 * For each storage device that the user specified, we
1011 * search and see if there is a resource for that device.
1013 foreach_alist(store, dirstore) {
1015 foreach_alist(device_name, store->device) {
1017 rctx.device_name = device_name;
1018 stat = search_res_for_device(rctx);
1019 if (stat == 1) { /* found available device */
1020 Dmsg1(dbglvl, "available device found=%s\n", device_name);
1023 } else if (stat == 0) { /* device busy */
1024 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
1026 /* otherwise error */
1027 Dmsg0(dbglvl, "No suitable device found.\n");
1038 * Search for a particular storage device with particular storage
1039 * characteristics (MediaType).
1041 int search_res_for_device(RCTX &rctx)
1043 AUTOCHANGER *changer;
1046 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
1047 /* Look through Autochangers first */
1048 foreach_res(changer, R_AUTOCHANGER) {
1049 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
1050 /* Find resource, and make sure we were able to open it */
1051 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1052 /* Try each device in this AutoChanger */
1053 foreach_alist(rctx.device, changer->device) {
1054 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
1055 stat = reserve_device(rctx);
1056 if (stat != 1) { /* try another device */
1060 if (rctx.store->append == SD_APPEND) {
1061 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1062 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1064 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1065 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1072 /* Now if requested look through regular devices */
1073 if (!rctx.autochanger_only) {
1074 foreach_res(rctx.device, R_DEVICE) {
1075 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
1076 /* Find resource, and make sure we were able to open it */
1077 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1078 stat = reserve_device(rctx);
1079 if (stat != 1) { /* try another device */
1083 if (rctx.store->append == SD_APPEND) {
1084 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1085 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1087 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1088 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1094 return -1; /* nothing found */
1098 * Try to reserve a specific device.
1100 * Returns: 1 -- OK, have DCR
1104 static int reserve_device(RCTX &rctx)
1108 const int name_len = MAX_NAME_LENGTH;
1110 /* Make sure MediaType is OK */
1111 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
1112 rctx.device->media_type, rctx.store->media_type);
1113 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1117 /* Make sure device exists -- i.e. we can stat() it */
1118 if (!rctx.device->dev) {
1119 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1121 if (!rctx.device->dev) {
1122 if (rctx.device->changer_res) {
1123 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1124 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1125 rctx.device->hdr.name, rctx.device_name);
1127 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1128 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1131 return -1; /* no use waiting */
1134 rctx.suitable_device = true;
1135 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1136 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1138 BSOCK *dir = rctx.jcr->dir_bsock;
1139 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1140 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1143 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1144 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1145 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1146 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1147 if (rctx.store->append == SD_APPEND) {
1148 Dmsg2(dbglvl, "call reserve for append: have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
1149 ok = reserve_device_for_append(dcr, rctx);
1154 rctx.jcr->dcr = dcr;
1155 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1156 dcr->dev->reserved_device,
1157 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1158 Dmsg3(dbglvl, "Vol=%s num_writers=%d, have_vol=%d\n",
1159 rctx.VolumeName, dcr->dev->num_writers, rctx.have_volume);
1160 if (rctx.have_volume) {
1161 if (reserve_volume(dcr, rctx.VolumeName)) {
1162 Dmsg1(dbglvl, "Reserved vol=%s\n", rctx.VolumeName);
1164 Dmsg1(dbglvl, "Could not reserve vol=%s\n", rctx.VolumeName);
1168 dcr->any_volume = true;
1169 Dmsg0(dbglvl, "no vol, call find_next_appendable_vol.\n");
1170 if (dir_find_next_appendable_volume(dcr)) {
1171 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1172 rctx.have_volume = true;
1173 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
1175 Dmsg0(dbglvl, "No next volume found\n");
1176 rctx.have_volume = false;
1177 rctx.VolumeName[0] = 0;
1179 * If there is at least one volume that is valid and in use,
1180 * but we get here, check if we are running with prefers
1181 * non-mounted drives. In that case, we have selected a
1182 * non-used drive and our one and only volume is mounted
1183 * elsewhere, so we bail out and retry using that drive.
1185 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1186 rctx.PreferMountedVols = true;
1187 if (dcr->VolumeName[0]) {
1188 unreserve_device(dcr);
1193 * Note. Under some circumstances, the Director can hand us
1194 * a Volume name that is not the same as the one on the current
1195 * drive, and in that case, the call above to find the next
1196 * volume will fail because in attempting to reserve the Volume
1197 * the code will realize that we already have a tape mounted,
1198 * and it will fail. This *should* only happen if there are
1199 * writers, thus the following test. In that case, we simply
1200 * bail out, and continue waiting, rather than plunging on
1201 * and hoping that the operator can resolve the problem.
1203 if (dcr->dev->num_writers != 0) {
1204 if (dcr->VolumeName[0]) {
1205 unreserve_device(dcr);
1212 ok = reserve_device_for_read(dcr);
1214 rctx.jcr->read_dcr = dcr;
1215 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1216 dcr->dev->reserved_device,
1217 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1224 if (rctx.notify_dir) {
1226 BSOCK *dir = rctx.jcr->dir_bsock;
1227 pm_strcpy(dev_name, rctx.device->hdr.name);
1228 bash_spaces(dev_name);
1229 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1230 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1237 rctx.have_volume = false;
1238 rctx.VolumeName[0] = 0;
1239 Dmsg0(dbglvl, "Not OK.\n");
1244 * We "reserve" the drive by setting the ST_READ bit. No one else
1245 * should touch the drive until that is cleared.
1246 * This allows the DIR to "reserve" the device before actually
1249 static bool reserve_device_for_read(DCR *dcr)
1251 DEVICE *dev = dcr->dev;
1252 JCR *jcr = dcr->jcr;
1259 if (is_device_unmounted(dev)) {
1260 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
1261 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1262 jcr->JobId, dev->print_name());
1263 queue_reserve_message(jcr);
1267 if (dev->is_busy()) {
1268 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1270 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1271 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1272 jcr->JobId, dev->print_name());
1273 queue_reserve_message(jcr);
1277 dev->clear_append();
1280 dev->reserved_device++;
1281 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev);
1282 dcr->reserved_device = true;
1291 * We reserve the device for appending by incrementing the
1292 * reserved_device. We do virtually all the same work that
1293 * is done in acquire_device_for_append(), but we do
1294 * not attempt to mount the device. This routine allows
1295 * the DIR to reserve multiple devices before *really*
1296 * starting the job. It also permits the SD to refuse
1297 * certain devices (not up, ...).
1299 * Note, in reserving a device, if the device is for the
1300 * same pool and the same pool type, then it is acceptable.
1301 * The Media Type has already been checked. If we are
1302 * the first tor reserve the device, we put the pool
1303 * name and pool type in the device record.
1305 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1307 JCR *jcr = dcr->jcr;
1308 DEVICE *dev = dcr->dev;
1315 /* If device is being read, we cannot write it */
1316 if (dev->can_read()) {
1317 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1318 jcr->JobId, dev->print_name());
1319 Dmsg1(dbglvl, "%s", jcr->errmsg);
1320 queue_reserve_message(jcr);
1324 /* If device is unmounted, we are out of luck */
1325 if (is_device_unmounted(dev)) {
1326 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1327 jcr->JobId, dev->print_name());
1328 Dmsg1(dbglvl, "%s", jcr->errmsg);
1329 queue_reserve_message(jcr);
1333 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
1335 /* Now do detailed tests ... */
1336 if (can_reserve_drive(dcr, rctx) != 1) {
1337 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
1341 dev->reserved_device++;
1342 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device,
1343 dev->print_name(), dev);
1344 dcr->reserved_device = true;
1352 static int is_pool_ok(DCR *dcr)
1354 DEVICE *dev = dcr->dev;
1355 JCR *jcr = dcr->jcr;
1357 /* Now check if we want the same Pool and pool type */
1358 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1359 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1360 /* OK, compatible device */
1361 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1364 /* Drive Pool not suitable for us */
1365 Mmsg(jcr->errmsg, _(
1366 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1367 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1368 dev->reserved_device, dev->print_name());
1369 queue_reserve_message(jcr);
1370 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1371 dev->pool_name, dcr->pool_name);
1376 static bool is_max_jobs_ok(DCR *dcr)
1378 DEVICE *dev = dcr->dev;
1379 JCR *jcr = dcr->jcr;
1381 Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n",
1382 dcr->VolCatInfo.VolCatMaxJobs,
1383 dcr->VolCatInfo.VolCatJobs, dev->reserved_device,
1385 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1386 (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) {
1387 /* Max Job Vols depassed or already reserved */
1388 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1389 (uint32_t)jcr->JobId, dev->print_name());
1390 queue_reserve_message(jcr);
1391 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1392 return false; /* wait */
1398 * Returns: 1 if drive can be reserved
1399 * 0 if we should wait
1400 * -1 on error or impossibility
1402 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1404 DEVICE *dev = dcr->dev;
1405 JCR *jcr = dcr->jcr;
1407 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1408 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1409 rctx.autochanger_only, rctx.any_drive);
1411 /* Check for max jobs on this Volume */
1412 if (!is_max_jobs_ok(dcr)) {
1416 /* setting any_drive overrides PreferMountedVols flag */
1417 if (!rctx.any_drive) {
1419 * When PreferMountedVols is set, we keep track of the
1420 * drive in use that has the least number of writers, then if
1421 * no unmounted drive is found, we try that drive. This
1422 * helps spread the load to the least used drives.
1424 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1425 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
1426 dev->print_name(), rctx.low_use_drive->print_name());
1429 /* If he wants a free drive, but this one is busy, no go */
1430 if (!rctx.PreferMountedVols && dev->is_busy()) {
1431 /* Save least used drive */
1432 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1433 rctx.num_writers = dev->num_writers + dev->reserved_device;
1434 rctx.low_use_drive = dev;
1435 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
1436 dev->print_name(), rctx.num_writers);
1438 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->reserved_device);
1440 Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
1441 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1442 jcr->JobId, dev->print_name());
1443 queue_reserve_message(jcr);
1447 /* Check for prefer mounted volumes */
1448 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1449 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1450 jcr->JobId, dev->print_name());
1451 queue_reserve_message(jcr);
1452 Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
1453 return 0; /* No volume mounted */
1456 /* Check for exact Volume name match */
1457 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1460 if (rctx.exact_match && rctx.have_volume) {
1462 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1463 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1464 rctx.autochanger_only, rctx.any_drive);
1465 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1466 rctx.have_volume, dev->VolHdr.VolumeName,
1467 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1468 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1469 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1471 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1472 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1474 queue_reserve_message(jcr);
1475 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1476 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1479 if (is_volume_in_use(dcr)) {
1480 return 0; /* fail if volume on another drive */
1485 /* Check for unused autochanger drive */
1486 if (rctx.autochanger_only && !dev->is_busy() &&
1487 dev->VolHdr.VolumeName[0] == 0) {
1488 /* Device is available but not yet reserved, reserve it for us */
1489 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1490 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1491 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1492 return 1; /* reserve drive */
1496 * Handle the case that there are no writers
1498 if (dev->num_writers == 0) {
1499 /* Now check if there are any reservations on the drive */
1500 if (dev->reserved_device) {
1501 return is_pool_ok(dcr);
1502 } else if (dev->can_append()) {
1503 if (is_pool_ok(dcr)) {
1506 /* Changing pool, unload old tape if any in drive */
1507 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1508 unload_autochanger(dcr, 0);
1511 /* Device is available but not yet reserved, reserve it for us */
1512 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1513 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1514 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1515 return 1; /* reserve drive */
1519 * Check if the device is in append mode with writers (i.e.
1520 * available if pool is the same).
1522 if (dev->can_append() || dev->num_writers > 0) {
1523 return is_pool_ok(dcr);
1525 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1526 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1527 jcr->JobId, dev->print_name());
1528 queue_reserve_message(jcr);
1529 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1530 return -1; /* error, should not get here */
1532 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1533 jcr->JobId, dev->print_name());
1534 queue_reserve_message(jcr);
1535 Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1543 * Queue a reservation error or failure message for this jcr
1545 static void queue_reserve_message(JCR *jcr)
1553 msgs = jcr->reserve_msgs;
1558 * Look for duplicate message. If found, do
1561 for (i=msgs->size()-1; i >= 0; i--) {
1562 msg = (char *)msgs->get(i);
1566 /* Comparison based on 4 digit message number */
1567 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1571 /* Message unique, so insert it */
1572 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1579 * Send any reservation messages queued for this jcr
1581 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1588 msgs = jcr->reserve_msgs;
1589 if (!msgs || msgs->size() == 0) {
1592 for (i=msgs->size()-1; i >= 0; i--) {
1593 msg = (char *)msgs->get(i);
1595 sendit(" ", 3, arg);
1596 sendit(msg, strlen(msg), arg);
1607 * Pop and release any reservations messages
1609 static void pop_reserve_messages(JCR *jcr)
1615 msgs = jcr->reserve_msgs;
1619 while ((msg = (char *)msgs->pop())) {
1627 * Also called from acquire.c
1629 void release_reserve_messages(JCR *jcr)
1631 pop_reserve_messages(jcr);
1633 if (!jcr->reserve_msgs) {
1636 delete jcr->reserve_msgs;
1637 jcr->reserve_msgs = NULL;