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);
57 /* Requests from the Director daemon */
58 static char use_storage[] = "use storage=%127s media_type=%127s "
59 "pool_name=%127s pool_type=%127s append=%d copy=%d stripe=%d\n";
60 static char use_device[] = "use device=%127s\n";
62 /* Responses sent to Director daemon */
63 static char OK_device[] = "3000 OK use device device=%s\n";
64 static char NO_device[] = "3924 Device \"%s\" not in SD Device resources.\n";
65 static char BAD_use[] = "3913 Bad use command: %s\n";
67 bool use_cmd(JCR *jcr)
70 * Get the device, media, and pool information
72 if (!use_storage_cmd(jcr)) {
73 set_jcr_job_status(jcr, JS_ErrorTerminated);
74 memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
80 static int my_compare(void *item1, void *item2)
82 return strcmp(((VOLRES *)item1)->vol_name, ((VOLRES *)item2)->vol_name);
86 * This allows a given thread to recursively call lock_reservations.
87 * It must, of course, call unlock_... the same number of times.
89 void init_reservations_lock()
92 if ((errstat=rwl_init(&reservation_lock)) != 0) {
94 Emsg1(M_ABORT, 0, _("Unable to initialize reservation lock. ERR=%s\n"),
95 be.bstrerror(errstat));
98 if ((errstat=rwl_init(&vol_list_lock)) != 0) {
100 Emsg1(M_ABORT, 0, _("Unable to initialize volume list lock. ERR=%s\n"),
101 be.bstrerror(errstat));
105 void term_reservations_lock()
107 rwl_destroy(&reservation_lock);
108 rwl_destroy(&vol_list_lock);
111 int reservations_lock_count = 0;
113 /* This applies to a drive and to Volumes */
114 void _lock_reservations()
117 reservations_lock_count++;
118 if ((errstat=rwl_writelock(&reservation_lock)) != 0) {
120 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
121 errstat, be.bstrerror(errstat));
125 void _unlock_reservations()
128 reservations_lock_count--;
129 if ((errstat=rwl_writeunlock(&reservation_lock)) != 0) {
131 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
132 errstat, be.bstrerror(errstat));
136 int vol_list_lock_count = 0;
139 * This allows a given thread to recursively call to lock_volumes()
144 vol_list_lock_count++;
145 if ((errstat=rwl_writelock(&vol_list_lock)) != 0) {
147 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
148 errstat, be.bstrerror(errstat));
152 void _unlock_volumes()
155 vol_list_lock_count--;
156 if ((errstat=rwl_writeunlock(&vol_list_lock)) != 0) {
158 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
159 errstat, be.bstrerror(errstat));
165 * List Volumes -- this should be moved to status.c
172 static void debug_list_volumes(const char *imsg)
175 POOL_MEM msg(PM_MESSAGE);
178 foreach_dlist(vol, vol_list) {
180 Mmsg(msg, "List from %s: %s at %p on device %s\n", imsg,
181 vol->vol_name, vol->vol_name, vol->dev->print_name());
183 Mmsg(msg, "List from %s: %s at %p no dev\n", imsg, vol->vol_name, vol->vol_name);
185 Dmsg1(dbglvl, "%s", msg.c_str());
190 foreach_dlist(vol, vol_list) {
191 if (vol->dev == dev) {
192 Dmsg0(dbglvl, "Two Volumes on same device.\n");
199 // Dmsg2(dbglvl, "List from %s: %d volumes\n", imsg, count);
205 * List Volumes -- this should be moved to status.c
207 void list_volumes(void sendit(const char *msg, int len, void *sarg), void *arg)
210 POOL_MEM msg(PM_MESSAGE);
214 foreach_dlist(vol, vol_list) {
215 DEVICE *dev = vol->dev;
217 len = Mmsg(msg, "%s on device %s\n", vol->vol_name, dev->print_name());
218 sendit(msg.c_str(), len, arg);
219 len = Mmsg(msg, " Reader=%d writers=%d reserved=%d released=%d\n",
220 dev->can_read()?1:0, dev->num_writers, dev->reserved_device, vol->released);
221 sendit(msg.c_str(), len, arg);
223 len = Mmsg(msg, "%s no device. released=%d\n", vol->vol_name, vol->released);
224 sendit(msg.c_str(), len, arg);
231 * Create a Volume item to put in the Volume list
232 * Ensure that the device points to it.
234 static VOLRES *new_vol_item(DCR *dcr, const char *VolumeName)
237 vol = (VOLRES *)malloc(sizeof(VOLRES));
238 memset(vol, 0, sizeof(VOLRES));
239 vol->vol_name = bstrdup(VolumeName);
241 Dmsg3(dbglvl, "new Vol=%s at %p dev=%s\n",
242 VolumeName, vol->vol_name, vol->dev->print_name());
246 static void free_vol_item(VOLRES *vol)
250 vol->dev->vol = NULL;
257 * Put a new Volume entry in the Volume list. This
258 * effectively reserves the volume so that it will
259 * not be mounted again.
261 * If the device has any current volume associated with it,
262 * and it is a different Volume, and the device is not busy,
263 * we release the old Volume item and insert the new one.
265 * It is assumed that the device is free and locked so that
266 * we can change the device structure.
268 * Some details of the Volume list handling:
270 * 1. The Volume list entry must be attached to the drive (rather than
271 * attached to a job as it currently is. I.e. the drive that "owns"
272 * the volume (reserved, in use, mounted)
273 * must point to the volume (still to be maintained in a list).
275 * 2. The Volume is entered in the list when a drive is reserved.
277 * 3. When a drive is in use, the device code must appropriately update the
278 * volume name as it changes (currently the list is static -- an entry is
279 * removed when the Volume is no longer reserved, in use or mounted).
280 * The new code must keep the same list entry as long as the drive
281 * has any volume associated with it but the volume name in the list
282 * must be updated when the drive has a different volume mounted.
284 * 4. A job that has reserved a volume, can un-reserve the volume, and if the
285 * volume is not mounted, and not reserved, and not in use, it will be
286 * removed from the list.
288 * 5. If a job wants to reserve a drive with a different Volume from the one on
289 * the drive, it can re-use the drive for the new Volume.
291 * 6. If a job wants a Volume that is in a different drive, it can either use the
292 * other drive or take the volume, only if the other drive is not in use or
295 * One nice aspect of this is that the reserve use count and the writer use count
296 * already exist and are correctly programmed and will need no changes -- use
297 * counts are always very tricky.
299 * The old code had a concept of "reserving" a Volume, but was changed
300 * to reserving and using a drive. A volume is must be attached to (owned by) a
301 * drive and can move from drive to drive or be unused given certain specific
302 * conditions of the drive. The key is that the drive must "own" the Volume.
303 * The old code had the job (dcr) owning the volume (more or less). The job was
304 * to change the insertion and removal of the volumes from the list to be based
305 * on the drive rather than the job.
307 * Return: VOLRES entry on success
308 * NULL volume busy on another drive
310 VOLRES *reserve_volume(DCR *dcr, const char *VolumeName)
313 DEVICE *dev = dcr->dev;
317 Dmsg1(dbglvl, "reserve_volume %s\n", VolumeName);
319 * We lock the reservations system here to ensure
320 * when adding a new volume that no newly scheduled
321 * job can reserve it.
324 debug_list_volumes("begin reserve_volume");
326 * First, remove any old volume attached to this device as it
332 * Make sure we don't remove the current volume we are inserting
333 * because it was probably inserted by another job, or it
334 * is not being used and is marked as released.
336 if (strcmp(vol->vol_name, VolumeName) == 0) {
337 Dmsg1(dbglvl, "OK, vol=%s on device.\n", VolumeName);
338 vol->released = false; /* retake vol if released previously */
339 goto get_out; /* Volume already on this device */
341 /* Don't release a volume if it is in use */
342 if (!vol->released) {
343 Dmsg1(dbglvl, "Cannot free vol=%s. It is not released.\n", vol->vol_name);
344 vol = NULL; /* vol in use */
347 Dmsg2(dbglvl, "reserve_vol free vol=%s at %p\n", vol->vol_name, vol->vol_name);
348 unload_autochanger(dcr, -1); /* unload the volume */
350 debug_list_volumes("reserve_vol free");
354 /* Create a new Volume entry */
355 nvol = new_vol_item(dcr, VolumeName);
358 * Now try to insert the new Volume
360 vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
362 Dmsg2(dbglvl, "Found vol=%s dev-same=%d\n", vol->vol_name, dev==vol->dev);
364 * At this point, a Volume with this name already is in the list,
365 * so we simply release our new Volume entry. Note, this should
366 * only happen if we are moving the volume from one drive to another.
368 Dmsg2(dbglvl, "reserve_vol free-tmp vol=%s at %p\n",
369 vol->vol_name, vol->vol_name);
371 * Clear dev pointer so that free_vol_item() doesn't
372 * take away our volume.
374 nvol->dev = NULL; /* don't zap dev entry */
377 /* Check if we are trying to use the Volume on a different drive */
378 if (dev != vol->dev) {
379 /* Caller wants to switch Volume to another device */
380 if (!vol->dev->is_busy()) {
381 /* OK to move it -- I'm not sure this will work */
382 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n", VolumeName,
383 vol->dev->print_name(), dev->print_name());
384 vol->dev->vol = NULL; /* take vol from old drive */
385 vol->dev->VolHdr.VolumeName[0] = 0;
386 vol->dev = dev; /* point vol at new drive */
387 dev->vol = vol; /* point dev at vol */
388 dev->VolHdr.VolumeName[0] = 0;
390 Dmsg3(dbglvl, "Volume busy could not swap vol=%s from dev=%s to %s\n",
391 VolumeName, vol->dev->print_name(), dev->print_name());
392 vol = NULL; /* device busy */
401 vol->released = false;
403 debug_list_volumes("end new volume");
409 * Switch from current device to given device
412 void switch_device(DCR *dcr, DEVICE *dev)
414 // lock_reservations();
418 memcpy(&save_dcr, dcr, sizeof(save_dcr));
419 clean_device(dcr); /* clean up the dcr */
421 dcr->dev = dev; /* get new device pointer */
422 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
423 dcr->dev->print_name());
425 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
426 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
427 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
428 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
429 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
430 bstrncpy(dcr->dev_name, save_dcr.dev_name, sizeof(dcr->dev_name));
432 dev->reserved_device++;
433 dcr->reserved_device = true;
439 * Search for a Volume name in the Volume list.
441 * Returns: VOLRES entry on success
442 * NULL if the Volume is not in the list
444 VOLRES *find_volume(DCR *dcr)
447 /* Do not lock reservations here */
449 vol.vol_name = bstrdup(dcr->VolumeName);
450 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
452 Dmsg2(dbglvl, "find_vol=%s found=%d\n", dcr->VolumeName, fvol!=NULL);
453 debug_list_volumes("find_volume");
459 * Remove any reservation from a drive and tell the system
460 * that the volume is unused at least by us.
462 void unreserve_device(DCR *dcr)
464 DEVICE *dev = dcr->dev;
465 if (dcr->reserved_device) {
466 dcr->reserved_device = false;
467 dev->reserved_device--;
468 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name());
469 dcr->reserved_device = false;
470 /* If we set read mode in reserving, remove it */
471 if (dev->can_read()) {
474 if (dev->num_writers < 0) {
475 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
476 dev->num_writers = 0;
478 if (dev->reserved_device == 0 && dev->num_writers == 0) {
485 * Free a Volume from the Volume list if it is no longer used
486 * Note, for tape drives we want to remember where the Volume
487 * was when last used, so rather than free the volume entry,
488 * we simply mark it "released" so when the drive is really
489 * needed for another volume, we can reuse it.
491 * Returns: true if the Volume found and "removed" from the list
492 * false if the Volume is not in the list or is in use
494 bool volume_unused(DCR *dcr)
496 DEVICE *dev = dcr->dev;
498 if (dev->vol == NULL) {
499 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
500 debug_list_volumes("null vol cannot unreserve_volume");
505 if (dev->is_busy()) {
506 Dmsg1(dbglvl, "vol_unused: busy on %s\n", dev->print_name());
507 debug_list_volumes("dev busy cannot unreserve_volume");
511 Dmsg2(dbglvl, "mark released. num_writers=%d reserved=%d\n",
512 dev->num_writers, dev->reserved_device);
514 if (dev->num_writers > 0 || dev->reserved_device > 0) {
520 * If this is a tape, we do not free the volume, rather we wait
521 * until the autoloader unloads it, or until another tape is
522 * explicitly read in this drive. This allows the SD to remember
523 * where the tapes are or last were.
525 dev->vol->released = true;
526 if (dev->is_tape() || dev->is_autochanger()) {
530 * Note, this frees the volume reservation entry, but the
531 * file descriptor remains open with the OS.
533 return free_volume(dev);
538 * Unconditionally release the volume entry
540 bool free_volume(DEVICE *dev)
544 if (dev->vol == NULL) {
545 Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name());
551 vol_list->remove(vol);
552 Dmsg2(dbglvl, "free_volume %s dev=%s\n", vol->vol_name, dev->print_name());
554 debug_list_volumes("free_volume");
560 /* Create the Volume list */
561 void create_volume_list()
564 if (vol_list == NULL) {
565 vol_list = New(dlist(vol, &vol->link));
569 /* Release all Volumes from the list */
570 void free_volume_list()
577 foreach_dlist(vol, vol_list) {
579 Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name());
581 Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name);
584 vol->vol_name = NULL;
591 bool is_volume_in_use(DCR *dcr)
593 VOLRES *vol = find_volume(dcr);
595 Dmsg1(dbglvl, "Vol=%s not in use.\n", dcr->VolumeName);
596 return false; /* vol not in list */
598 ASSERT(vol->dev != NULL);
600 if (dcr->dev == vol->dev) { /* same device OK */
601 Dmsg1(dbglvl, "Vol=%s on same dev.\n", dcr->VolumeName);
604 Dmsg3(dbglvl, "Vol=%s on %s we have %s\n", dcr->VolumeName,
605 vol->dev->print_name(), dcr->dev->print_name());
607 if (!vol->dev->is_busy()) {
608 Dmsg2(dbglvl, "Vol=%s dev=%s not busy.\n", dcr->VolumeName, vol->dev->print_name());
611 Dmsg2(dbglvl, "Vol=%s dev=%s busy.\n", dcr->VolumeName, vol->dev->print_name());
613 Dmsg2(dbglvl, "Vol=%s in use by %s.\n", dcr->VolumeName, vol->dev->print_name());
619 * We get the following type of information:
621 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
625 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
629 static bool use_storage_cmd(JCR *jcr)
631 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
632 BSOCK *dir = jcr->dir_bsock;
640 memset(&rctx, 0, sizeof(RCTX));
643 * If there are multiple devices, the director sends us
644 * use_device for each device that it wants to use.
646 dirstore = New(alist(10, not_owned_by_alist));
647 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
649 Dmsg1(dbglvl, "<dird: %s", dir->msg);
650 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
651 media_type.c_str(), pool_name.c_str(),
652 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
657 jcr->write_store = dirstore;
659 jcr->read_store = dirstore;
661 rctx.append = append;
662 unbash_spaces(store_name);
663 unbash_spaces(media_type);
664 unbash_spaces(pool_name);
665 unbash_spaces(pool_type);
666 store = new DIRSTORE;
667 dirstore->append(store);
668 memset(store, 0, sizeof(DIRSTORE));
669 store->device = New(alist(10));
670 bstrncpy(store->name, store_name, sizeof(store->name));
671 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
672 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
673 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
674 store->append = append;
676 /* Now get all devices */
677 while (dir->recv() >= 0) {
678 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
679 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
683 unbash_spaces(dev_name);
684 store->device->append(bstrdup(dev_name.c_str()));
686 } while (ok && dir->recv() >= 0);
688 /* Developer debug code */
690 if (debug_level >= dbglvl) {
691 foreach_alist(store, dirstore) {
692 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
693 store->name, store->media_type, store->pool_name,
694 store->pool_type, store->append);
695 foreach_alist(device_name, store->device) {
696 Dmsg1(dbglvl, " Device=%s\n", device_name);
701 init_jcr_device_wait_timers(jcr);
702 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
704 BSOCK *dir = jcr->dir_bsock;
705 dir->fsend(_("3939 Could not get dcr\n"));
706 Dmsg1(dbglvl, ">dird: %s", dir->msg);
710 * At this point, we have a list of all the Director's Storage
711 * resources indicated for this Job, which include Pool, PoolType,
712 * storage name, and Media type.
713 * Then for each of the Storage resources, we have a list of
714 * device names that were given.
716 * Wiffle through them and find one that can do the backup.
719 int wait_for_device_retries = 0;
722 rctx.notify_dir = true;
725 for ( ; !fail && !job_canceled(jcr); ) {
726 pop_reserve_messages(jcr);
727 rctx.suitable_device = false;
728 rctx.have_volume = false;
729 rctx.VolumeName[0] = 0;
730 rctx.any_drive = false;
731 if (!jcr->PreferMountedVols) {
733 * Here we try to find a drive that is not used.
734 * This will maximize the use of available drives.
737 rctx.num_writers = 20000000; /* start with impossible number */
738 rctx.low_use_drive = NULL;
739 rctx.PreferMountedVols = false;
740 rctx.exact_match = false;
741 rctx.autochanger_only = true;
742 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
743 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
744 rctx.autochanger_only, rctx.any_drive);
745 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
748 /* Look through all drives possibly for low_use drive */
749 if (rctx.low_use_drive) {
750 rctx.try_low_use_drive = true;
751 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
754 rctx.try_low_use_drive = false;
756 rctx.autochanger_only = false;
757 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
758 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
759 rctx.autochanger_only, rctx.any_drive);
760 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
765 * Now we look for a drive that may or may not be in
768 /* Look for an exact Volume match all drives */
769 rctx.PreferMountedVols = true;
770 rctx.exact_match = true;
771 rctx.autochanger_only = false;
772 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
773 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
774 rctx.autochanger_only, rctx.any_drive);
775 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
778 /* Look for any mounted drive */
779 rctx.exact_match = 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))) {
787 rctx.any_drive = true;
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))) {
794 /* Keep reservations locked *except* during wait_for_device() */
795 unlock_reservations();
797 * The idea of looping on repeat a few times it to ensure
798 * that if there is some subtle timing problem between two
799 * jobs, we will simply try again, and most likely succeed.
800 * This can happen if one job reserves a drive or finishes using
801 * a drive at the same time a second job wants it.
803 if (repeat++ > 1) { /* try algorithm 3 times */
804 bmicrosleep(30, 0); /* wait a bit */
805 Dmsg0(dbglvl, "repeat reserve algorithm\n");
806 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
807 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
811 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
813 unlock_reservations();
816 * If we get here, there are no suitable devices available, which
817 * means nothing configured. If a device is suitable but busy
818 * with another Volume, we will not come here.
820 unbash_spaces(dir->msg);
821 pm_strcpy(jcr->errmsg, dir->msg);
822 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
823 Jmsg(jcr, M_FATAL, 0, _("\n"
824 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
825 dev_name.c_str(), media_type.c_str());
826 dir->fsend(NO_device, dev_name.c_str());
828 Dmsg1(dbglvl, ">dird: %s", dir->msg);
831 unbash_spaces(dir->msg);
832 pm_strcpy(jcr->errmsg, dir->msg);
833 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
834 dir->fsend(BAD_use, jcr->errmsg);
835 Dmsg1(dbglvl, ">dird: %s", dir->msg);
838 release_reserve_messages(jcr);
844 * Walk through the autochanger resources and check if
845 * the volume is in one of them.
847 * Returns: true if volume is in device
850 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
852 AUTOCHANGER *changer = vol->dev->device->changer_res;
854 /* Find resource, and make sure we were able to open it */
855 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
856 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
859 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
864 * Search for a device suitable for this job.
866 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
875 dirstore = jcr->write_store;
877 dirstore = jcr->read_store;
879 Dmsg4(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
880 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
881 rctx.autochanger_only);
884 * If the appropriate conditions of this if are met, namely that
885 * we are appending and the user wants mounted drive (or we
886 * force try a mounted drive because they are all busy), we
887 * start by looking at all the Volumes in the volume list.
889 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
890 dlist *temp_vol_list, *save_vol_list;
893 Dmsg0(dbglvl, "lock volumes\n");
896 * Create a temporary copy of the volume list. We do this,
897 * to avoid having the volume list locked during the
898 * call to reserve_device(), which would cause a deadlock.
899 * Note, we may want to add an update counter on the vol_list
900 * so that if it is modified while we are traversing the copy
901 * we can take note and act accordingly (probably redo the
902 * search at least a few times).
904 Dmsg0(dbglvl, "duplicate vol list\n");
905 temp_vol_list = New(dlist(vol, &vol->link));
906 foreach_dlist(vol, vol_list) {
908 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
909 memset(tvol, 0, sizeof(VOLRES));
910 tvol->vol_name = bstrdup(vol->vol_name);
911 tvol->dev = vol->dev;
912 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
914 tvol->dev = NULL; /* don't zap dev entry */
916 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
917 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
920 Dmsg0(dbglvl, "unlock volumes\n");
923 /* Look through reserved volumes for one we can use */
924 Dmsg0(dbglvl, "look for vol in vol list\n");
925 foreach_dlist(vol, temp_vol_list) {
927 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
930 /* Check with Director if this Volume is OK */
931 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
932 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
936 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
937 foreach_alist(store, dirstore) {
940 foreach_alist(device_name, store->device) {
941 /* Found a device, try to use it */
942 rctx.device_name = device_name;
943 rctx.device = vol->dev->device;
945 if (vol->dev->is_autochanger()) {
946 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
947 if (!is_vol_in_autochanger(rctx, vol)) {
950 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
951 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
952 vol->dev->device->hdr.name, device_name);
956 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
957 rctx.have_volume = true;
958 /* Try reserving this device and volume */
959 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
960 stat = reserve_device(rctx);
961 if (stat == 1) { /* found available device */
962 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
965 } else if (stat == 0) { /* device busy */
966 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
968 /* otherwise error */
969 Dmsg0(dbglvl, "No suitable device found.\n");
971 rctx.have_volume = false;
980 } /* end for loop over reserved volumes */
982 Dmsg0(dbglvl, "lock volumes\n");
984 save_vol_list = vol_list;
985 vol_list = temp_vol_list;
986 free_volume_list(); /* release temp_vol_list */
987 vol_list = save_vol_list;
988 Dmsg0(dbglvl, "deleted temp vol list\n");
989 Dmsg0(dbglvl, "unlock volumes\n");
991 debug_list_volumes("=== After free temp table\n");
994 Dmsg1(dbglvl, "got vol %s from in-use vols list\n", rctx.VolumeName);
999 * No reserved volume we can use, so now search for an available device.
1001 * For each storage device that the user specified, we
1002 * search and see if there is a resource for that device.
1004 foreach_alist(store, dirstore) {
1006 foreach_alist(device_name, store->device) {
1008 rctx.device_name = device_name;
1009 stat = search_res_for_device(rctx);
1010 if (stat == 1) { /* found available device */
1011 Dmsg1(dbglvl, "available device found=%s\n", device_name);
1014 } else if (stat == 0) { /* device busy */
1015 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
1017 /* otherwise error */
1018 Dmsg0(dbglvl, "No suitable device found.\n");
1029 * Search for a particular storage device with particular storage
1030 * characteristics (MediaType).
1032 int search_res_for_device(RCTX &rctx)
1034 AUTOCHANGER *changer;
1037 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
1038 /* Look through Autochangers first */
1039 foreach_res(changer, R_AUTOCHANGER) {
1040 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
1041 /* Find resource, and make sure we were able to open it */
1042 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1043 /* Try each device in this AutoChanger */
1044 foreach_alist(rctx.device, changer->device) {
1045 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
1046 stat = reserve_device(rctx);
1047 if (stat != 1) { /* try another device */
1051 if (rctx.store->append == SD_APPEND) {
1052 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1053 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1055 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1056 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1063 /* Now if requested look through regular devices */
1064 if (!rctx.autochanger_only) {
1065 foreach_res(rctx.device, R_DEVICE) {
1066 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
1067 /* Find resource, and make sure we were able to open it */
1068 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1069 stat = reserve_device(rctx);
1070 if (stat != 1) { /* try another device */
1074 if (rctx.store->append == SD_APPEND) {
1075 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1076 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1078 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1079 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1085 return -1; /* nothing found */
1089 * Try to reserve a specific device.
1091 * Returns: 1 -- OK, have DCR
1095 static int reserve_device(RCTX &rctx)
1099 const int name_len = MAX_NAME_LENGTH;
1101 /* Make sure MediaType is OK */
1102 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
1103 rctx.device->media_type, rctx.store->media_type);
1104 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1108 /* Make sure device exists -- i.e. we can stat() it */
1109 if (!rctx.device->dev) {
1110 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1112 if (!rctx.device->dev) {
1113 if (rctx.device->changer_res) {
1114 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1115 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1116 rctx.device->hdr.name, rctx.device_name);
1118 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1119 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1122 return -1; /* no use waiting */
1125 rctx.suitable_device = true;
1126 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1127 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1129 BSOCK *dir = rctx.jcr->dir_bsock;
1130 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1131 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1134 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1135 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1136 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1137 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1138 if (rctx.store->append == SD_APPEND) {
1139 Dmsg2(dbglvl, "have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
1140 ok = reserve_device_for_append(dcr, rctx);
1145 rctx.jcr->dcr = dcr;
1146 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1147 dcr->dev->reserved_device,
1148 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1149 if (!rctx.have_volume) {
1150 dcr->any_volume = true;
1151 if (dir_find_next_appendable_volume(dcr)) {
1152 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1153 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
1154 rctx.have_volume = true;
1156 Dmsg0(dbglvl, "No next volume found\n");
1157 rctx.have_volume = false;
1158 rctx.VolumeName[0] = 0;
1160 * If there is at least one volume that is valid and in use,
1161 * but we get here, check if we are running with prefers
1162 * non-mounted drives. In that case, we have selected a
1163 * non-used drive and our one and only volume is mounted
1164 * elsewhere, so we bail out and retry using that drive.
1166 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1167 rctx.PreferMountedVols = true;
1168 if (dcr->VolumeName[0]) {
1169 // volume_unused(dcr);
1174 * Note. Under some circumstances, the Director can hand us
1175 * a Volume name that is no the same as the one on the current
1176 * drive, and in that case, the call above to find the next
1177 * volume will fail because in attempting to reserve the Volume
1178 * the code will realize that we already have a tape mounted,
1179 * and it will fail. This *should* only happen if there are
1180 * writers, thus the following test. In that case, we simply
1181 * bail out, and continue waiting, rather than plunging on
1182 * and hoping that the operator can resolve the problem.
1184 if (dcr->dev->num_writers != 0) {
1185 if (dcr->VolumeName[0]) {
1186 // volume_unused(dcr);
1193 ok = reserve_device_for_read(dcr);
1195 rctx.jcr->read_dcr = dcr;
1196 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1197 dcr->dev->reserved_device,
1198 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1204 if (rctx.notify_dir) {
1206 BSOCK *dir = rctx.jcr->dir_bsock;
1207 pm_strcpy(dev_name, rctx.device->hdr.name);
1208 bash_spaces(dev_name);
1209 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1210 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1217 rctx.have_volume = false;
1219 Dmsg0(dbglvl, "Not OK.\n");
1224 * We "reserve" the drive by setting the ST_READ bit. No one else
1225 * should touch the drive until that is cleared.
1226 * This allows the DIR to "reserve" the device before actually
1229 static bool reserve_device_for_read(DCR *dcr)
1231 DEVICE *dev = dcr->dev;
1232 JCR *jcr = dcr->jcr;
1239 if (is_device_unmounted(dev)) {
1240 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
1241 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1242 jcr->JobId, dev->print_name());
1243 queue_reserve_message(jcr);
1247 if (dev->is_busy()) {
1248 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1250 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1251 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1252 jcr->JobId, dev->print_name());
1253 queue_reserve_message(jcr);
1257 dev->clear_append();
1260 dev->reserved_device++;
1261 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev);
1262 dcr->reserved_device = true;
1271 * We reserve the device for appending by incrementing the
1272 * reserved_device. We do virtually all the same work that
1273 * is done in acquire_device_for_append(), but we do
1274 * not attempt to mount the device. This routine allows
1275 * the DIR to reserve multiple devices before *really*
1276 * starting the job. It also permits the SD to refuse
1277 * certain devices (not up, ...).
1279 * Note, in reserving a device, if the device is for the
1280 * same pool and the same pool type, then it is acceptable.
1281 * The Media Type has already been checked. If we are
1282 * the first tor reserve the device, we put the pool
1283 * name and pool type in the device record.
1285 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1287 JCR *jcr = dcr->jcr;
1288 DEVICE *dev = dcr->dev;
1295 /* If device is being read, we cannot write it */
1296 if (dev->can_read()) {
1297 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1298 jcr->JobId, dev->print_name());
1299 Dmsg1(dbglvl, "%s", jcr->errmsg);
1300 queue_reserve_message(jcr);
1304 /* If device is unmounted, we are out of luck */
1305 if (is_device_unmounted(dev)) {
1306 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1307 jcr->JobId, dev->print_name());
1308 Dmsg1(dbglvl, "%s", jcr->errmsg);
1309 queue_reserve_message(jcr);
1313 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
1315 /* Now do detailed tests ... */
1316 if (can_reserve_drive(dcr, rctx) != 1) {
1317 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
1321 dev->reserved_device++;
1322 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device,
1323 dev->print_name(), dev);
1324 dcr->reserved_device = true;
1332 static int is_pool_ok(DCR *dcr)
1334 DEVICE *dev = dcr->dev;
1335 JCR *jcr = dcr->jcr;
1337 /* Now check if we want the same Pool and pool type */
1338 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1339 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1340 /* OK, compatible device */
1341 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1344 /* Drive Pool not suitable for us */
1345 Mmsg(jcr->errmsg, _(
1346 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1347 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1348 dev->reserved_device, dev->print_name());
1349 queue_reserve_message(jcr);
1350 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1351 dev->pool_name, dcr->pool_name);
1356 static bool is_max_jobs_ok(DCR *dcr)
1358 DEVICE *dev = dcr->dev;
1359 JCR *jcr = dcr->jcr;
1361 Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n",
1362 dcr->VolCatInfo.VolCatMaxJobs,
1363 dcr->VolCatInfo.VolCatJobs, dev->reserved_device,
1365 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1366 (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) {
1367 /* Max Job Vols depassed or already reserved */
1368 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1369 (uint32_t)jcr->JobId, dev->print_name());
1370 queue_reserve_message(jcr);
1371 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1372 return false; /* wait */
1378 * Returns: 1 if drive can be reserved
1379 * 0 if we should wait
1380 * -1 on error or impossibility
1382 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1384 DEVICE *dev = dcr->dev;
1385 JCR *jcr = dcr->jcr;
1387 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1388 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1389 rctx.autochanger_only, rctx.any_drive);
1391 /* Check for max jobs on this Volume */
1392 if (!is_max_jobs_ok(dcr)) {
1396 /* setting any_drive overrides PreferMountedVols flag */
1397 if (!rctx.any_drive) {
1399 * When PreferMountedVols is set, we keep track of the
1400 * drive in use that has the least number of writers, then if
1401 * no unmounted drive is found, we try that drive. This
1402 * helps spread the load to the least used drives.
1404 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1405 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
1406 dev->print_name(), rctx.low_use_drive->print_name());
1409 /* If he wants a free drive, but this one is busy, no go */
1410 if (!rctx.PreferMountedVols && dev->is_busy()) {
1411 /* Save least used drive */
1412 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1413 rctx.num_writers = dev->num_writers + dev->reserved_device;
1414 rctx.low_use_drive = dev;
1415 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
1416 dev->print_name(), rctx.num_writers);
1418 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->reserved_device);
1420 Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
1421 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1422 jcr->JobId, dev->print_name());
1423 queue_reserve_message(jcr);
1427 /* Check for prefer mounted volumes */
1428 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1429 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1430 jcr->JobId, dev->print_name());
1431 queue_reserve_message(jcr);
1432 Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
1433 return 0; /* No volume mounted */
1436 /* Check for exact Volume name match */
1437 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1440 if (rctx.exact_match && rctx.have_volume) {
1442 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1443 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1444 rctx.autochanger_only, rctx.any_drive);
1445 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1446 rctx.have_volume, dev->VolHdr.VolumeName,
1447 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1448 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1449 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1451 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1452 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1454 queue_reserve_message(jcr);
1455 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1456 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1459 if (is_volume_in_use(dcr)) {
1460 return 0; /* fail if volume on another drive */
1465 /* Check for unused autochanger drive */
1466 if (rctx.autochanger_only && !dev->is_busy() &&
1467 dev->VolHdr.VolumeName[0] == 0) {
1468 /* Device is available but not yet reserved, reserve it for us */
1469 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1470 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1471 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1472 return 1; /* reserve drive */
1476 * Handle the case that there are no writers
1478 if (dev->num_writers == 0) {
1479 /* Now check if there are any reservations on the drive */
1480 if (dev->reserved_device) {
1481 return is_pool_ok(dcr);
1482 } else if (dev->can_append()) {
1483 if (is_pool_ok(dcr)) {
1486 /* Changing pool, unload old tape if any in drive */
1487 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1488 unload_autochanger(dcr, 0);
1491 /* Device is available but not yet reserved, reserve it for us */
1492 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1493 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1494 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1495 return 1; /* reserve drive */
1499 * Check if the device is in append mode with writers (i.e.
1500 * available if pool is the same).
1502 if (dev->can_append() || dev->num_writers > 0) {
1503 return is_pool_ok(dcr);
1505 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1506 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1507 jcr->JobId, dev->print_name());
1508 queue_reserve_message(jcr);
1509 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1510 return -1; /* error, should not get here */
1512 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1513 jcr->JobId, dev->print_name());
1514 queue_reserve_message(jcr);
1515 Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1523 * Queue a reservation error or failure message for this jcr
1525 static void queue_reserve_message(JCR *jcr)
1533 msgs = jcr->reserve_msgs;
1538 * Look for duplicate message. If found, do
1541 for (i=msgs->size()-1; i >= 0; i--) {
1542 msg = (char *)msgs->get(i);
1546 /* Comparison based on 4 digit message number */
1547 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1551 /* Message unique, so insert it */
1552 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1559 * Send any reservation messages queued for this jcr
1561 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1568 msgs = jcr->reserve_msgs;
1569 if (!msgs || msgs->size() == 0) {
1572 for (i=msgs->size()-1; i >= 0; i--) {
1573 msg = (char *)msgs->get(i);
1575 sendit(" ", 3, arg);
1576 sendit(msg, strlen(msg), arg);
1587 * Pop and release any reservations messages
1589 static void pop_reserve_messages(JCR *jcr)
1595 msgs = jcr->reserve_msgs;
1599 while ((msg = (char *)msgs->pop())) {
1607 * Also called from acquire.c
1609 void release_reserve_messages(JCR *jcr)
1611 pop_reserve_messages(jcr);
1613 if (!jcr->reserve_msgs) {
1616 delete jcr->reserve_msgs;
1617 jcr->reserve_msgs = NULL;