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)
263 * Put a new Volume entry in the Volume list. This
264 * effectively reserves the volume so that it will
265 * not be mounted again.
267 * If the device has any current volume associated with it,
268 * and it is a different Volume, and the device is not busy,
269 * we release the old Volume item and insert the new one.
271 * It is assumed that the device is free and locked so that
272 * we can change the device structure.
274 * Some details of the Volume list handling:
276 * 1. The Volume list entry must be attached to the drive (rather than
277 * attached to a job as it currently is. I.e. the drive that "owns"
278 * the volume (reserved, in use, mounted)
279 * must point to the volume (still to be maintained in a list).
281 * 2. The Volume is entered in the list when a drive is reserved.
283 * 3. When a drive is in use, the device code must appropriately update the
284 * volume name as it changes (currently the list is static -- an entry is
285 * removed when the Volume is no longer reserved, in use or mounted).
286 * The new code must keep the same list entry as long as the drive
287 * has any volume associated with it but the volume name in the list
288 * must be updated when the drive has a different volume mounted.
290 * 4. A job that has reserved a volume, can un-reserve the volume, and if the
291 * volume is not mounted, and not reserved, and not in use, it will be
292 * removed from the list.
294 * 5. If a job wants to reserve a drive with a different Volume from the one on
295 * the drive, it can re-use the drive for the new Volume.
297 * 6. If a job wants a Volume that is in a different drive, it can either use the
298 * other drive or take the volume, only if the other drive is not in use or
301 * One nice aspect of this is that the reserve use count and the writer use count
302 * already exist and are correctly programmed and will need no changes -- use
303 * counts are always very tricky.
305 * The old code had a concept of "reserving" a Volume, but was changed
306 * to reserving and using a drive. A volume is must be attached to (owned by) a
307 * drive and can move from drive to drive or be unused given certain specific
308 * conditions of the drive. The key is that the drive must "own" the Volume.
309 * The old code had the job (dcr) owning the volume (more or less). The job was
310 * to change the insertion and removal of the volumes from the list to be based
311 * on the drive rather than the job.
313 * Return: VOLRES entry on success
314 * NULL volume busy on another drive
316 VOLRES *reserve_volume(DCR *dcr, const char *VolumeName)
319 DEVICE * volatile dev = dcr->dev;
323 Dmsg1(dbglvl, "enter reserve_volume %s\n", VolumeName);
325 * We lock the reservations system here to ensure
326 * when adding a new volume that no newly scheduled
327 * job can reserve it.
330 debug_list_volumes("begin reserve_volume");
332 * First, remove any old volume attached to this device as it
337 Dmsg4(dbglvl, "Vol attached=%s, newvol=%s release=%d on %s\n",
338 vol->vol_name, VolumeName, vol->released, dev->print_name());
340 * Make sure we don't remove the current volume we are inserting
341 * because it was probably inserted by another job, or it
342 * is not being used and is marked as released.
344 if (strcmp(vol->vol_name, VolumeName) == 0) {
345 Dmsg2(dbglvl, "=== set not released vol=%s dev=%s\n", VolumeName,
346 vol->dev->print_name());
347 vol->released = false; /* retake vol if released previously */
348 dcr->reserved_volume = true; /* reserved volume */
349 goto get_out; /* Volume already on this device */
351 /* Don't release a volume if it is in use */
352 if (!vol->released && !dcr->reserved_volume) {
353 Dmsg1(dbglvl, "Cannot free vol=%s. It is not released.\n", vol->vol_name);
354 vol = NULL; /* vol in use */
357 Dmsg2(dbglvl, "reserve_vol free vol=%s at %p\n", vol->vol_name, vol->vol_name);
358 unload_autochanger(dcr, -1); /* unload the volume */
360 debug_list_volumes("reserve_vol free");
364 /* Create a new Volume entry */
365 nvol = new_vol_item(dcr, VolumeName);
368 * Now try to insert the new Volume
370 vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
372 Dmsg2(dbglvl, "Found vol=%s dev-same=%d\n", vol->vol_name, dev==vol->dev);
374 * At this point, a Volume with this name already is in the list,
375 * so we simply release our new Volume entry. Note, this should
376 * only happen if we are moving the volume from one drive to another.
378 Dmsg2(dbglvl, "reserve_vol free-tmp vol=%s at %p\n",
379 vol->vol_name, vol->vol_name);
381 * Clear dev pointer so that free_vol_item() doesn't
382 * take away our volume.
384 nvol->dev = NULL; /* don't zap dev entry */
387 /* Check if we are trying to use the Volume on a different drive */
388 if (dev != vol->dev) {
389 /* Caller wants to switch Volume to another device */
391 Dmsg2(dbglvl, "==== Swap from dev=%s to %s\n",
392 dev->print_name(), vol->dev->print_name());
393 vol->dev->vol = NULL; /* take vol from old drive */
394 switch_device(dcr, vol->dev);
396 bstrncpy(dcr->VolumeName, VolumeName, sizeof(dcr->VolumeName));
398 if (!vol->dev->is_busy()) {
399 vol->dev->vol = NULL; /* take vol from old drive */
400 if (vol->dev->Slot > 0) {
401 Dmsg1(dbglvl, "Unload dev=%s\n", vol->dev->print_name());
402 unload_dev(dcr, vol->dev);
404 /* OK to move it -- I'm not sure this will work */
405 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n", VolumeName,
406 vol->dev->print_name(), dev->print_name());
407 vol->dev->VolHdr.VolumeName[0] = 0;
408 vol->dev = dev; /* point vol at new drive */
409 dev->vol = vol; /* point dev at vol */
410 dev->VolHdr.VolumeName[0] = 0;
412 Dmsg3(dbglvl, "==== Swap not possible Vol busy vol=%s from dev=%s to %s\n",
413 VolumeName, vol->dev->print_name(), dev->print_name());
414 vol = NULL; /* device busy */
424 Dmsg2(dbglvl, "=== set not released. vol=%s dev=%s\n", vol->vol_name,
425 vol->dev->print_name());
426 vol->released = false;
427 dcr->reserved_volume = true;
429 debug_list_volumes("end new volume");
435 * Switch from current device to given device
438 void switch_device(DCR *dcr, DEVICE *dev)
443 memcpy(&save_dcr, dcr, sizeof(save_dcr));
444 clean_device(dcr); /* clean up the dcr */
446 dcr->dev = dev; /* get new device pointer */
447 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
448 dcr->dev->print_name());
450 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
451 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
452 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
453 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
454 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
455 bstrncpy(dcr->dev_name, dev->dev_name, sizeof(dcr->dev_name));
457 dev->reserved_device++;
458 dcr->reserved_device = true;
464 * Search for a Volume name in the Volume list.
466 * Returns: VOLRES entry on success
467 * NULL if the Volume is not in the list
469 VOLRES *find_volume(DCR *dcr)
472 /* Do not lock reservations here */
474 vol.vol_name = bstrdup(dcr->VolumeName);
475 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
477 Dmsg2(dbglvl, "find_vol=%s found=%d\n", dcr->VolumeName, fvol!=NULL);
478 debug_list_volumes("find_volume");
484 * Remove any reservation from a drive and tell the system
485 * that the volume is unused at least by us.
487 void unreserve_device(DCR *dcr)
489 DEVICE *dev = dcr->dev;
490 if (dcr->reserved_device) {
491 dcr->reserved_device = false;
492 dcr->reserved_volume = false;
493 dev->reserved_device--;
494 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name());
495 /* If we set read mode in reserving, remove it */
496 if (dev->can_read()) {
499 if (dev->num_writers < 0) {
500 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
501 dev->num_writers = 0;
503 if (dev->reserved_device == 0 && dev->num_writers == 0) {
510 * Free a Volume from the Volume list if it is no longer used
511 * Note, for tape drives we want to remember where the Volume
512 * was when last used, so rather than free the volume entry,
513 * we simply mark it "released" so when the drive is really
514 * needed for another volume, we can reuse it.
516 * Returns: true if the Volume found and "removed" from the list
517 * false if the Volume is not in the list or is in use
519 bool volume_unused(DCR *dcr)
521 DEVICE *dev = dcr->dev;
523 if (dev->vol == NULL) {
524 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
525 debug_list_volumes("null vol cannot unreserve_volume");
530 if (dev->is_busy()) {
531 Dmsg1(dbglvl, "vol_unused: busy on %s\n", dev->print_name());
532 debug_list_volumes("dev busy cannot unreserve_volume");
537 if (dev->num_writers > 0 || dev->reserved_device > 0) {
543 * If this is a tape, we do not free the volume, rather we wait
544 * until the autoloader unloads it, or until another tape is
545 * explicitly read in this drive. This allows the SD to remember
546 * where the tapes are or last were.
548 Dmsg3(dbglvl, "=== mark released vol=%s num_writers=%d dev_reserved=%d\n",
549 dev->vol->vol_name, dev->num_writers, dev->reserved_device);
550 dev->vol->released = true;
551 Dmsg2(dbglvl, "=== set released. Vol=%s dev=%s\n", dev->vol->vol_name,
553 if (dev->is_tape() || dev->is_autochanger()) {
557 * Note, this frees the volume reservation entry, but the
558 * file descriptor remains open with the OS.
560 return free_volume(dev);
565 * Unconditionally release the volume entry
567 bool free_volume(DEVICE *dev)
571 if (dev->vol == NULL) {
572 Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name());
578 vol_list->remove(vol);
579 Dmsg2(dbglvl, "=== free_volume %s dev=%s\n", vol->vol_name, dev->print_name());
581 debug_list_volumes("free_volume");
587 /* Create the Volume list */
588 void create_volume_list()
591 if (vol_list == NULL) {
592 vol_list = New(dlist(vol, &vol->link));
596 /* Release all Volumes from the list */
597 void free_volume_list()
604 foreach_dlist(vol, vol_list) {
606 Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name());
608 Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name);
611 vol->vol_name = NULL;
618 bool is_volume_in_use(DCR *dcr)
624 vol = find_volume(dcr);
626 Dmsg1(dbglvl, "Vol=%s not in use.\n", dcr->VolumeName);
627 goto get_out; /* vol not in list */
629 ASSERT(vol->dev != NULL);
631 if (dcr->dev == vol->dev) { /* same device OK */
632 Dmsg1(dbglvl, "Vol=%s on same dev.\n", dcr->VolumeName);
635 Dmsg3(dbglvl, "Vol=%s on %s we have %s\n", dcr->VolumeName,
636 vol->dev->print_name(), dcr->dev->print_name());
638 if (!vol->dev->is_busy()) {
639 Dmsg2(dbglvl, "Vol=%s dev=%s not busy.\n", dcr->VolumeName, vol->dev->print_name());
642 Dmsg2(dbglvl, "Vol=%s dev=%s busy.\n", dcr->VolumeName, vol->dev->print_name());
644 Dmsg2(dbglvl, "Vol=%s in use by %s.\n", dcr->VolumeName, vol->dev->print_name());
655 * We get the following type of information:
657 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
661 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
665 static bool use_storage_cmd(JCR *jcr)
667 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
668 BSOCK *dir = jcr->dir_bsock;
676 memset(&rctx, 0, sizeof(RCTX));
679 * If there are multiple devices, the director sends us
680 * use_device for each device that it wants to use.
682 dirstore = New(alist(10, not_owned_by_alist));
683 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
685 Dmsg1(dbglvl, "<dird: %s", dir->msg);
686 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
687 media_type.c_str(), pool_name.c_str(),
688 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
693 jcr->write_store = dirstore;
695 jcr->read_store = dirstore;
697 rctx.append = append;
698 unbash_spaces(store_name);
699 unbash_spaces(media_type);
700 unbash_spaces(pool_name);
701 unbash_spaces(pool_type);
702 store = new DIRSTORE;
703 dirstore->append(store);
704 memset(store, 0, sizeof(DIRSTORE));
705 store->device = New(alist(10));
706 bstrncpy(store->name, store_name, sizeof(store->name));
707 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
708 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
709 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
710 store->append = append;
712 /* Now get all devices */
713 while (dir->recv() >= 0) {
714 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
715 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
719 unbash_spaces(dev_name);
720 store->device->append(bstrdup(dev_name.c_str()));
722 } while (ok && dir->recv() >= 0);
724 /* Developer debug code */
726 if (debug_level >= dbglvl) {
727 foreach_alist(store, dirstore) {
728 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
729 store->name, store->media_type, store->pool_name,
730 store->pool_type, store->append);
731 foreach_alist(device_name, store->device) {
732 Dmsg1(dbglvl, " Device=%s\n", device_name);
737 init_jcr_device_wait_timers(jcr);
738 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
740 BSOCK *dir = jcr->dir_bsock;
741 dir->fsend(_("3939 Could not get dcr\n"));
742 Dmsg1(dbglvl, ">dird: %s", dir->msg);
746 * At this point, we have a list of all the Director's Storage
747 * resources indicated for this Job, which include Pool, PoolType,
748 * storage name, and Media type.
749 * Then for each of the Storage resources, we have a list of
750 * device names that were given.
752 * Wiffle through them and find one that can do the backup.
755 int wait_for_device_retries = 0;
758 rctx.notify_dir = true;
761 for ( ; !fail && !job_canceled(jcr); ) {
762 pop_reserve_messages(jcr);
763 rctx.suitable_device = false;
764 rctx.have_volume = false;
765 rctx.VolumeName[0] = 0;
766 rctx.any_drive = false;
767 if (!jcr->PreferMountedVols) {
769 * Here we try to find a drive that is not used.
770 * This will maximize the use of available drives.
773 rctx.num_writers = 20000000; /* start with impossible number */
774 rctx.low_use_drive = NULL;
775 rctx.PreferMountedVols = false;
776 rctx.exact_match = false;
777 rctx.autochanger_only = true;
778 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
779 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
780 rctx.autochanger_only, rctx.any_drive);
781 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
784 /* Look through all drives possibly for low_use drive */
785 if (rctx.low_use_drive) {
786 rctx.try_low_use_drive = true;
787 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
790 rctx.try_low_use_drive = false;
792 rctx.autochanger_only = false;
793 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
794 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
795 rctx.autochanger_only, rctx.any_drive);
796 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
801 * Now we look for a drive that may or may not be in
804 /* Look for an exact Volume match all drives */
805 rctx.PreferMountedVols = true;
806 rctx.exact_match = true;
807 rctx.autochanger_only = false;
808 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
809 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
810 rctx.autochanger_only, rctx.any_drive);
811 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
814 /* Look for any mounted drive */
815 rctx.exact_match = false;
816 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
817 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
818 rctx.autochanger_only, rctx.any_drive);
819 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
823 rctx.any_drive = true;
824 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
825 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
826 rctx.autochanger_only, rctx.any_drive);
827 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
830 /* Keep reservations locked *except* during wait_for_device() */
831 unlock_reservations();
833 * The idea of looping on repeat a few times it to ensure
834 * that if there is some subtle timing problem between two
835 * jobs, we will simply try again, and most likely succeed.
836 * This can happen if one job reserves a drive or finishes using
837 * a drive at the same time a second job wants it.
839 if (repeat++ > 1) { /* try algorithm 3 times */
840 bmicrosleep(30, 0); /* wait a bit */
841 Dmsg0(dbglvl, "repeat reserve algorithm\n");
842 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
843 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
847 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
849 unlock_reservations();
852 * If we get here, there are no suitable devices available, which
853 * means nothing configured. If a device is suitable but busy
854 * with another Volume, we will not come here.
856 unbash_spaces(dir->msg);
857 pm_strcpy(jcr->errmsg, dir->msg);
858 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
859 Jmsg(jcr, M_FATAL, 0, _("\n"
860 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
861 dev_name.c_str(), media_type.c_str());
862 dir->fsend(NO_device, dev_name.c_str());
864 Dmsg1(dbglvl, ">dird: %s", dir->msg);
867 unbash_spaces(dir->msg);
868 pm_strcpy(jcr->errmsg, dir->msg);
869 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
870 dir->fsend(BAD_use, jcr->errmsg);
871 Dmsg1(dbglvl, ">dird: %s", dir->msg);
874 release_reserve_messages(jcr);
880 * Walk through the autochanger resources and check if
881 * the volume is in one of them.
883 * Returns: true if volume is in device
886 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
888 AUTOCHANGER *changer = vol->dev->device->changer_res;
890 /* Find resource, and make sure we were able to open it */
891 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
892 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
895 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
900 * Search for a device suitable for this job.
901 * Note, this routine sets sets rctx.suitable_device if any
902 * device exists within the SD. The device may not be actually
904 * It also returns if it finds a useable device.
906 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
915 dirstore = jcr->write_store;
917 dirstore = jcr->read_store;
919 Dmsg4(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
920 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
921 rctx.autochanger_only);
924 * If the appropriate conditions of this if are met, namely that
925 * we are appending and the user wants mounted drive (or we
926 * force try a mounted drive because they are all busy), we
927 * start by looking at all the Volumes in the volume list.
929 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
930 dlist *temp_vol_list, *save_vol_list;
933 Dmsg0(dbglvl, "lock volumes\n");
936 * Create a temporary copy of the volume list. We do this,
937 * to avoid having the volume list locked during the
938 * call to reserve_device(), which would cause a deadlock.
939 * Note, we may want to add an update counter on the vol_list
940 * so that if it is modified while we are traversing the copy
941 * we can take note and act accordingly (probably redo the
942 * search at least a few times).
944 Dmsg0(dbglvl, "duplicate vol list\n");
945 temp_vol_list = New(dlist(vol, &vol->link));
946 foreach_dlist(vol, vol_list) {
948 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
949 memset(tvol, 0, sizeof(VOLRES));
950 tvol->vol_name = bstrdup(vol->vol_name);
951 tvol->dev = vol->dev;
952 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
954 tvol->dev = NULL; /* don't zap dev entry */
956 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
957 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
960 Dmsg0(dbglvl, "unlock volumes\n");
963 /* Look through reserved volumes for one we can use */
964 Dmsg0(dbglvl, "look for vol in vol list\n");
965 foreach_dlist(vol, temp_vol_list) {
967 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
970 /* Check with Director if this Volume is OK */
971 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
972 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
976 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
977 foreach_alist(store, dirstore) {
980 foreach_alist(device_name, store->device) {
981 /* Found a device, try to use it */
982 rctx.device_name = device_name;
983 rctx.device = vol->dev->device;
985 if (vol->dev->is_autochanger()) {
986 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
987 if (!is_vol_in_autochanger(rctx, vol)) {
990 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
991 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
992 vol->dev->device->hdr.name, device_name);
996 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
997 rctx.have_volume = true;
998 /* Try reserving this device and volume */
999 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
1000 stat = reserve_device(rctx);
1001 if (stat == 1) { /* found available device */
1002 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
1005 } else if (stat == 0) { /* device busy */
1006 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
1008 /* otherwise error */
1009 Dmsg0(dbglvl, "No suitable device found.\n");
1011 rctx.have_volume = false;
1012 rctx.VolumeName[0] = 0;
1021 } /* end for loop over reserved volumes */
1023 Dmsg0(dbglvl, "lock volumes\n");
1025 save_vol_list = vol_list;
1026 vol_list = temp_vol_list;
1027 free_volume_list(); /* release temp_vol_list */
1028 vol_list = save_vol_list;
1029 Dmsg0(dbglvl, "deleted temp vol list\n");
1030 Dmsg0(dbglvl, "unlock volumes\n");
1032 debug_list_volumes("=== After free temp table\n");
1035 Dmsg1(dbglvl, "Usable dev found. Vol=%s from in-use vols list\n", rctx.VolumeName);
1040 * No reserved volume we can use, so now search for an available device.
1042 * For each storage device that the user specified, we
1043 * search and see if there is a resource for that device.
1045 foreach_alist(store, dirstore) {
1047 foreach_alist(device_name, store->device) {
1049 rctx.device_name = device_name;
1050 stat = search_res_for_device(rctx);
1051 if (stat == 1) { /* found available device */
1052 Dmsg1(dbglvl, "available device found=%s\n", device_name);
1055 } else if (stat == 0) { /* device busy */
1056 Dmsg1(dbglvl, "No usable device=%s, busy: not use\n", device_name);
1058 /* otherwise error */
1059 Dmsg0(dbglvl, "No usable device found.\n");
1067 Dmsg1(dbglvl, "Usable dev found. Vol=%s\n", rctx.VolumeName);
1073 * Search for a particular storage device with particular storage
1074 * characteristics (MediaType).
1076 int search_res_for_device(RCTX &rctx)
1078 AUTOCHANGER *changer;
1081 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
1082 /* Look through Autochangers first */
1083 foreach_res(changer, R_AUTOCHANGER) {
1084 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
1085 /* Find resource, and make sure we were able to open it */
1086 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1087 /* Try each device in this AutoChanger */
1088 foreach_alist(rctx.device, changer->device) {
1089 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
1090 stat = reserve_device(rctx);
1091 if (stat != 1) { /* try another device */
1095 if (rctx.store->append == SD_APPEND) {
1096 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1097 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1099 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1100 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1107 /* Now if requested look through regular devices */
1108 if (!rctx.autochanger_only) {
1109 foreach_res(rctx.device, R_DEVICE) {
1110 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
1111 /* Find resource, and make sure we were able to open it */
1112 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1113 stat = reserve_device(rctx);
1114 if (stat != 1) { /* try another device */
1118 if (rctx.store->append == SD_APPEND) {
1119 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1120 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1122 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1123 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1129 return -1; /* nothing found */
1133 * Try to reserve a specific device.
1135 * Returns: 1 -- OK, have DCR
1139 static int reserve_device(RCTX &rctx)
1143 const int name_len = MAX_NAME_LENGTH;
1145 /* Make sure MediaType is OK */
1146 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
1147 rctx.device->media_type, rctx.store->media_type);
1148 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1152 /* Make sure device exists -- i.e. we can stat() it */
1153 if (!rctx.device->dev) {
1154 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1156 if (!rctx.device->dev) {
1157 if (rctx.device->changer_res) {
1158 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1159 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1160 rctx.device->hdr.name, rctx.device_name);
1162 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1163 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1166 return -1; /* no use waiting */
1169 rctx.suitable_device = true;
1170 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1171 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1173 BSOCK *dir = rctx.jcr->dir_bsock;
1174 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1175 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1178 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1179 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1180 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1181 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1182 if (rctx.store->append == SD_APPEND) {
1183 Dmsg2(dbglvl, "call reserve for append: have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
1184 ok = reserve_device_for_append(dcr, rctx);
1189 rctx.jcr->dcr = dcr;
1190 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1191 dcr->dev->reserved_device,
1192 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1193 Dmsg3(dbglvl, "Vol=%s num_writers=%d, have_vol=%d\n",
1194 rctx.VolumeName, dcr->dev->num_writers, rctx.have_volume);
1195 if (rctx.have_volume) {
1196 Dmsg0(dbglvl, "Call reserve_volume\n");
1197 if (reserve_volume(dcr, rctx.VolumeName)) {
1198 Dmsg1(dbglvl, "Reserved vol=%s\n", rctx.VolumeName);
1200 Dmsg1(dbglvl, "Could not reserve vol=%s\n", rctx.VolumeName);
1204 dcr->any_volume = true;
1205 Dmsg0(dbglvl, "no vol, call find_next_appendable_vol.\n");
1206 if (dir_find_next_appendable_volume(dcr)) {
1207 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1208 rctx.have_volume = true;
1209 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
1211 Dmsg0(dbglvl, "No next volume found\n");
1212 rctx.have_volume = false;
1213 rctx.VolumeName[0] = 0;
1215 * If there is at least one volume that is valid and in use,
1216 * but we get here, check if we are running with prefers
1217 * non-mounted drives. In that case, we have selected a
1218 * non-used drive and our one and only volume is mounted
1219 * elsewhere, so we bail out and retry using that drive.
1221 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1222 rctx.PreferMountedVols = true;
1223 if (dcr->VolumeName[0]) {
1224 unreserve_device(dcr);
1229 * Note. Under some circumstances, the Director can hand us
1230 * a Volume name that is not the same as the one on the current
1231 * drive, and in that case, the call above to find the next
1232 * volume will fail because in attempting to reserve the Volume
1233 * the code will realize that we already have a tape mounted,
1234 * and it will fail. This *should* only happen if there are
1235 * writers, thus the following test. In that case, we simply
1236 * bail out, and continue waiting, rather than plunging on
1237 * and hoping that the operator can resolve the problem.
1239 if (dcr->dev->num_writers != 0) {
1240 if (dcr->VolumeName[0]) {
1241 unreserve_device(dcr);
1248 ok = reserve_device_for_read(dcr);
1250 rctx.jcr->read_dcr = dcr;
1251 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1252 dcr->dev->reserved_device,
1253 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1260 if (rctx.notify_dir) {
1262 BSOCK *dir = rctx.jcr->dir_bsock;
1263 pm_strcpy(dev_name, rctx.device->hdr.name);
1264 bash_spaces(dev_name);
1265 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1266 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1273 rctx.have_volume = false;
1274 rctx.VolumeName[0] = 0;
1275 Dmsg0(dbglvl, "Not OK.\n");
1280 * We "reserve" the drive by setting the ST_READ bit. No one else
1281 * should touch the drive until that is cleared.
1282 * This allows the DIR to "reserve" the device before actually
1285 static bool reserve_device_for_read(DCR *dcr)
1287 DEVICE *dev = dcr->dev;
1288 JCR *jcr = dcr->jcr;
1295 if (is_device_unmounted(dev)) {
1296 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
1297 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1298 jcr->JobId, dev->print_name());
1299 queue_reserve_message(jcr);
1303 if (dev->is_busy()) {
1304 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1306 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1307 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1308 jcr->JobId, dev->print_name());
1309 queue_reserve_message(jcr);
1313 dev->clear_append();
1316 dev->reserved_device++;
1317 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev);
1318 dcr->reserved_device = true;
1327 * We reserve the device for appending by incrementing the
1328 * reserved_device. We do virtually all the same work that
1329 * is done in acquire_device_for_append(), but we do
1330 * not attempt to mount the device. This routine allows
1331 * the DIR to reserve multiple devices before *really*
1332 * starting the job. It also permits the SD to refuse
1333 * certain devices (not up, ...).
1335 * Note, in reserving a device, if the device is for the
1336 * same pool and the same pool type, then it is acceptable.
1337 * The Media Type has already been checked. If we are
1338 * the first tor reserve the device, we put the pool
1339 * name and pool type in the device record.
1341 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1343 JCR *jcr = dcr->jcr;
1344 DEVICE *dev = dcr->dev;
1351 /* If device is being read, we cannot write it */
1352 if (dev->can_read()) {
1353 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1354 jcr->JobId, dev->print_name());
1355 Dmsg1(dbglvl, "%s", jcr->errmsg);
1356 queue_reserve_message(jcr);
1360 /* If device is unmounted, we are out of luck */
1361 if (is_device_unmounted(dev)) {
1362 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1363 jcr->JobId, dev->print_name());
1364 Dmsg1(dbglvl, "%s", jcr->errmsg);
1365 queue_reserve_message(jcr);
1369 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
1371 /* Now do detailed tests ... */
1372 if (can_reserve_drive(dcr, rctx) != 1) {
1373 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
1377 dev->reserved_device++;
1378 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device,
1379 dev->print_name(), dev);
1380 dcr->reserved_device = true;
1388 static int is_pool_ok(DCR *dcr)
1390 DEVICE *dev = dcr->dev;
1391 JCR *jcr = dcr->jcr;
1393 /* Now check if we want the same Pool and pool type */
1394 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1395 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1396 /* OK, compatible device */
1397 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1400 /* Drive Pool not suitable for us */
1401 Mmsg(jcr->errmsg, _(
1402 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1403 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1404 dev->reserved_device, dev->print_name());
1405 queue_reserve_message(jcr);
1406 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1407 dev->pool_name, dcr->pool_name);
1412 static bool is_max_jobs_ok(DCR *dcr)
1414 DEVICE *dev = dcr->dev;
1415 JCR *jcr = dcr->jcr;
1417 Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n",
1418 dcr->VolCatInfo.VolCatMaxJobs,
1419 dcr->VolCatInfo.VolCatJobs, dev->reserved_device,
1421 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1422 (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) {
1423 /* Max Job Vols depassed or already reserved */
1424 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1425 (uint32_t)jcr->JobId, dev->print_name());
1426 queue_reserve_message(jcr);
1427 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1428 return false; /* wait */
1434 * Returns: 1 if drive can be reserved
1435 * 0 if we should wait
1436 * -1 on error or impossibility
1438 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1440 DEVICE *dev = dcr->dev;
1441 JCR *jcr = dcr->jcr;
1443 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1444 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1445 rctx.autochanger_only, rctx.any_drive);
1447 /* Check for max jobs on this Volume */
1448 if (!is_max_jobs_ok(dcr)) {
1452 /* setting any_drive overrides PreferMountedVols flag */
1453 if (!rctx.any_drive) {
1455 * When PreferMountedVols is set, we keep track of the
1456 * drive in use that has the least number of writers, then if
1457 * no unmounted drive is found, we try that drive. This
1458 * helps spread the load to the least used drives.
1460 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1461 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
1462 dev->print_name(), rctx.low_use_drive->print_name());
1465 /* If he wants a free drive, but this one is busy, no go */
1466 if (!rctx.PreferMountedVols && dev->is_busy()) {
1467 /* Save least used drive */
1468 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1469 rctx.num_writers = dev->num_writers + dev->reserved_device;
1470 rctx.low_use_drive = dev;
1471 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
1472 dev->print_name(), rctx.num_writers);
1474 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->reserved_device);
1476 Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
1477 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1478 jcr->JobId, dev->print_name());
1479 queue_reserve_message(jcr);
1483 /* Check for prefer mounted volumes */
1484 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1485 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1486 jcr->JobId, dev->print_name());
1487 queue_reserve_message(jcr);
1488 Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
1489 return 0; /* No volume mounted */
1492 /* Check for exact Volume name match */
1493 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1496 if (rctx.exact_match && rctx.have_volume) {
1498 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1499 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1500 rctx.autochanger_only, rctx.any_drive);
1501 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1502 rctx.have_volume, dev->VolHdr.VolumeName,
1503 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1504 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1505 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1507 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1508 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1510 queue_reserve_message(jcr);
1511 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1512 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1515 if (is_volume_in_use(dcr)) {
1516 return 0; /* fail if volume on another drive */
1521 /* Check for unused autochanger drive */
1522 if (rctx.autochanger_only && !dev->is_busy() &&
1523 dev->VolHdr.VolumeName[0] == 0) {
1524 /* Device is available but not yet reserved, reserve it for us */
1525 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1526 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1527 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1528 return 1; /* reserve drive */
1532 * Handle the case that there are no writers
1534 if (dev->num_writers == 0) {
1535 /* Now check if there are any reservations on the drive */
1536 if (dev->reserved_device) {
1537 return is_pool_ok(dcr);
1538 } else if (dev->can_append()) {
1539 if (is_pool_ok(dcr)) {
1542 /* Changing pool, unload old tape if any in drive */
1543 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1544 unload_autochanger(dcr, 0);
1547 /* Device is available but not yet reserved, reserve it for us */
1548 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1549 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1550 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1551 return 1; /* reserve drive */
1555 * Check if the device is in append mode with writers (i.e.
1556 * available if pool is the same).
1558 if (dev->can_append() || dev->num_writers > 0) {
1559 return is_pool_ok(dcr);
1561 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1562 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1563 jcr->JobId, dev->print_name());
1564 queue_reserve_message(jcr);
1565 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1566 return -1; /* error, should not get here */
1568 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1569 jcr->JobId, dev->print_name());
1570 queue_reserve_message(jcr);
1571 Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1579 * Queue a reservation error or failure message for this jcr
1581 static void queue_reserve_message(JCR *jcr)
1589 msgs = jcr->reserve_msgs;
1594 * Look for duplicate message. If found, do
1597 for (i=msgs->size()-1; i >= 0; i--) {
1598 msg = (char *)msgs->get(i);
1602 /* Comparison based on 4 digit message number */
1603 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1607 /* Message unique, so insert it */
1608 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1615 * Send any reservation messages queued for this jcr
1617 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1624 msgs = jcr->reserve_msgs;
1625 if (!msgs || msgs->size() == 0) {
1628 for (i=msgs->size()-1; i >= 0; i--) {
1629 msg = (char *)msgs->get(i);
1631 sendit(" ", 3, arg);
1632 sendit(msg, strlen(msg), arg);
1643 * Pop and release any reservations messages
1645 static void pop_reserve_messages(JCR *jcr)
1651 msgs = jcr->reserve_msgs;
1655 while ((msg = (char *)msgs->pop())) {
1663 * Also called from acquire.c
1665 void release_reserve_messages(JCR *jcr)
1667 pop_reserve_messages(jcr);
1669 if (!jcr->reserve_msgs) {
1672 delete jcr->reserve_msgs;
1673 jcr->reserve_msgs = NULL;