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 %s: %s rel=%d on device %s\n", imsg,
181 vol->vol_name, vol->released, vol->dev->print_name());
183 Mmsg(msg, "List %s: %s rel=%d no dev\n", imsg, vol->vol_name, vol->released);
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, "enter 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
331 Dmsg4(dbglvl, "Vol attached=%s, newvol=%s release=%d on %s\n",
332 vol->vol_name, VolumeName, vol->released, dev->print_name());
334 * Make sure we don't remove the current volume we are inserting
335 * because it was probably inserted by another job, or it
336 * is not being used and is marked as released.
338 if (strcmp(vol->vol_name, VolumeName) == 0) {
339 Dmsg1(dbglvl, "=== OK, vol=%s on device. set not released.\n", VolumeName);
340 vol->released = false; /* retake vol if released previously */
341 goto get_out; /* Volume already on this device */
343 /* Don't release a volume if it is in use */
344 if (!vol->released) {
345 Dmsg1(dbglvl, "Cannot free vol=%s. It is not released.\n", vol->vol_name);
346 vol = NULL; /* vol in use */
349 Dmsg2(dbglvl, "reserve_vol free vol=%s at %p\n", vol->vol_name, vol->vol_name);
350 unload_autochanger(dcr, -1); /* unload the volume */
352 debug_list_volumes("reserve_vol free");
356 /* Create a new Volume entry */
357 nvol = new_vol_item(dcr, VolumeName);
360 * Now try to insert the new Volume
362 vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
364 Dmsg2(dbglvl, "Found vol=%s dev-same=%d\n", vol->vol_name, dev==vol->dev);
366 * At this point, a Volume with this name already is in the list,
367 * so we simply release our new Volume entry. Note, this should
368 * only happen if we are moving the volume from one drive to another.
370 Dmsg2(dbglvl, "reserve_vol free-tmp vol=%s at %p\n",
371 vol->vol_name, vol->vol_name);
373 * Clear dev pointer so that free_vol_item() doesn't
374 * take away our volume.
376 nvol->dev = NULL; /* don't zap dev entry */
379 /* Check if we are trying to use the Volume on a different drive */
380 if (dev != vol->dev) {
381 /* Caller wants to switch Volume to another device */
382 if (!vol->dev->is_busy()) {
383 /* OK to move it -- I'm not sure this will work */
384 Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n", VolumeName,
385 vol->dev->print_name(), dev->print_name());
386 vol->dev->vol = NULL; /* take vol from old drive */
387 vol->dev->VolHdr.VolumeName[0] = 0;
388 vol->dev = dev; /* point vol at new drive */
389 dev->vol = vol; /* point dev at vol */
390 dev->VolHdr.VolumeName[0] = 0;
392 Dmsg3(dbglvl, "Volume busy could not swap vol=%s from dev=%s to %s\n",
393 VolumeName, vol->dev->print_name(), dev->print_name());
394 vol = NULL; /* device busy */
403 Dmsg1(dbglvl, "=== set not released. vol=%s\n", vol->vol_name);
404 vol->released = false;
406 debug_list_volumes("end new volume");
412 * Switch from current device to given device
415 void switch_device(DCR *dcr, DEVICE *dev)
417 // lock_reservations();
421 memcpy(&save_dcr, dcr, sizeof(save_dcr));
422 clean_device(dcr); /* clean up the dcr */
424 dcr->dev = dev; /* get new device pointer */
425 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
426 dcr->dev->print_name());
428 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
429 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
430 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
431 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
432 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
433 bstrncpy(dcr->dev_name, save_dcr.dev_name, sizeof(dcr->dev_name));
435 dev->reserved_device++;
436 dcr->reserved_device = true;
442 * Search for a Volume name in the Volume list.
444 * Returns: VOLRES entry on success
445 * NULL if the Volume is not in the list
447 VOLRES *find_volume(DCR *dcr)
450 /* Do not lock reservations here */
452 vol.vol_name = bstrdup(dcr->VolumeName);
453 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
455 Dmsg2(dbglvl, "find_vol=%s found=%d\n", dcr->VolumeName, fvol!=NULL);
456 debug_list_volumes("find_volume");
462 * Remove any reservation from a drive and tell the system
463 * that the volume is unused at least by us.
465 void unreserve_device(DCR *dcr)
467 DEVICE *dev = dcr->dev;
468 if (dcr->reserved_device) {
469 dcr->reserved_device = false;
470 dev->reserved_device--;
471 Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->reserved_device, dev->print_name());
472 dcr->reserved_device = false;
473 /* If we set read mode in reserving, remove it */
474 if (dev->can_read()) {
477 if (dev->num_writers < 0) {
478 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
479 dev->num_writers = 0;
481 if (dev->reserved_device == 0 && dev->num_writers == 0) {
488 * Free a Volume from the Volume list if it is no longer used
489 * Note, for tape drives we want to remember where the Volume
490 * was when last used, so rather than free the volume entry,
491 * we simply mark it "released" so when the drive is really
492 * needed for another volume, we can reuse it.
494 * Returns: true if the Volume found and "removed" from the list
495 * false if the Volume is not in the list or is in use
497 bool volume_unused(DCR *dcr)
499 DEVICE *dev = dcr->dev;
501 if (dev->vol == NULL) {
502 Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name());
503 debug_list_volumes("null vol cannot unreserve_volume");
508 if (dev->is_busy()) {
509 Dmsg1(dbglvl, "vol_unused: busy on %s\n", dev->print_name());
510 debug_list_volumes("dev busy cannot unreserve_volume");
515 if (dev->num_writers > 0 || dev->reserved_device > 0) {
521 * If this is a tape, we do not free the volume, rather we wait
522 * until the autoloader unloads it, or until another tape is
523 * explicitly read in this drive. This allows the SD to remember
524 * where the tapes are or last were.
526 Dmsg3(dbglvl, "=== mark released vol=%s num_writers=%d reserved=%d\n",
527 dev->vol->vol_name, dev->num_writers, dev->reserved_device);
528 dev->vol->released = true;
529 if (dev->is_tape()) { // || dev->is_autochanger()) {
533 * Note, this frees the volume reservation entry, but the
534 * file descriptor remains open with the OS.
536 return free_volume(dev);
541 * Unconditionally release the volume entry
543 bool free_volume(DEVICE *dev)
547 if (dev->vol == NULL) {
548 Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name());
554 vol_list->remove(vol);
555 Dmsg2(dbglvl, "=== free_volume %s dev=%s\n", vol->vol_name, dev->print_name());
557 debug_list_volumes("free_volume");
563 /* Create the Volume list */
564 void create_volume_list()
567 if (vol_list == NULL) {
568 vol_list = New(dlist(vol, &vol->link));
572 /* Release all Volumes from the list */
573 void free_volume_list()
580 foreach_dlist(vol, vol_list) {
582 Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name());
584 Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name);
587 vol->vol_name = NULL;
594 bool is_volume_in_use(DCR *dcr)
596 VOLRES *vol = find_volume(dcr);
598 Dmsg1(dbglvl, "Vol=%s not in use.\n", dcr->VolumeName);
599 return false; /* vol not in list */
601 ASSERT(vol->dev != NULL);
603 if (dcr->dev == vol->dev) { /* same device OK */
604 Dmsg1(dbglvl, "Vol=%s on same dev.\n", dcr->VolumeName);
607 Dmsg3(dbglvl, "Vol=%s on %s we have %s\n", dcr->VolumeName,
608 vol->dev->print_name(), dcr->dev->print_name());
610 if (!vol->dev->is_busy()) {
611 Dmsg2(dbglvl, "Vol=%s dev=%s not busy.\n", dcr->VolumeName, vol->dev->print_name());
614 Dmsg2(dbglvl, "Vol=%s dev=%s busy.\n", dcr->VolumeName, vol->dev->print_name());
616 Dmsg2(dbglvl, "Vol=%s in use by %s.\n", dcr->VolumeName, vol->dev->print_name());
622 * We get the following type of information:
624 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
628 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
632 static bool use_storage_cmd(JCR *jcr)
634 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
635 BSOCK *dir = jcr->dir_bsock;
643 memset(&rctx, 0, sizeof(RCTX));
646 * If there are multiple devices, the director sends us
647 * use_device for each device that it wants to use.
649 dirstore = New(alist(10, not_owned_by_alist));
650 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
652 Dmsg1(dbglvl, "<dird: %s", dir->msg);
653 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
654 media_type.c_str(), pool_name.c_str(),
655 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
660 jcr->write_store = dirstore;
662 jcr->read_store = dirstore;
664 rctx.append = append;
665 unbash_spaces(store_name);
666 unbash_spaces(media_type);
667 unbash_spaces(pool_name);
668 unbash_spaces(pool_type);
669 store = new DIRSTORE;
670 dirstore->append(store);
671 memset(store, 0, sizeof(DIRSTORE));
672 store->device = New(alist(10));
673 bstrncpy(store->name, store_name, sizeof(store->name));
674 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
675 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
676 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
677 store->append = append;
679 /* Now get all devices */
680 while (dir->recv() >= 0) {
681 Dmsg1(dbglvl, "<dird device: %s", dir->msg);
682 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
686 unbash_spaces(dev_name);
687 store->device->append(bstrdup(dev_name.c_str()));
689 } while (ok && dir->recv() >= 0);
691 /* Developer debug code */
693 if (debug_level >= dbglvl) {
694 foreach_alist(store, dirstore) {
695 Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
696 store->name, store->media_type, store->pool_name,
697 store->pool_type, store->append);
698 foreach_alist(device_name, store->device) {
699 Dmsg1(dbglvl, " Device=%s\n", device_name);
704 init_jcr_device_wait_timers(jcr);
705 jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */
707 BSOCK *dir = jcr->dir_bsock;
708 dir->fsend(_("3939 Could not get dcr\n"));
709 Dmsg1(dbglvl, ">dird: %s", dir->msg);
713 * At this point, we have a list of all the Director's Storage
714 * resources indicated for this Job, which include Pool, PoolType,
715 * storage name, and Media type.
716 * Then for each of the Storage resources, we have a list of
717 * device names that were given.
719 * Wiffle through them and find one that can do the backup.
722 int wait_for_device_retries = 0;
725 rctx.notify_dir = true;
728 for ( ; !fail && !job_canceled(jcr); ) {
729 pop_reserve_messages(jcr);
730 rctx.suitable_device = false;
731 rctx.have_volume = false;
732 rctx.VolumeName[0] = 0;
733 rctx.any_drive = false;
734 if (!jcr->PreferMountedVols) {
736 * Here we try to find a drive that is not used.
737 * This will maximize the use of available drives.
740 rctx.num_writers = 20000000; /* start with impossible number */
741 rctx.low_use_drive = NULL;
742 rctx.PreferMountedVols = false;
743 rctx.exact_match = false;
744 rctx.autochanger_only = true;
745 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
746 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
747 rctx.autochanger_only, rctx.any_drive);
748 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
751 /* Look through all drives possibly for low_use drive */
752 if (rctx.low_use_drive) {
753 rctx.try_low_use_drive = true;
754 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
757 rctx.try_low_use_drive = false;
759 rctx.autochanger_only = false;
760 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
761 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
762 rctx.autochanger_only, rctx.any_drive);
763 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
768 * Now we look for a drive that may or may not be in
771 /* Look for an exact Volume match all drives */
772 rctx.PreferMountedVols = true;
773 rctx.exact_match = true;
774 rctx.autochanger_only = false;
775 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
776 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
777 rctx.autochanger_only, rctx.any_drive);
778 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
781 /* Look for any mounted drive */
782 rctx.exact_match = false;
783 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
784 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
785 rctx.autochanger_only, rctx.any_drive);
786 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
790 rctx.any_drive = true;
791 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
792 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
793 rctx.autochanger_only, rctx.any_drive);
794 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
797 /* Keep reservations locked *except* during wait_for_device() */
798 unlock_reservations();
800 * The idea of looping on repeat a few times it to ensure
801 * that if there is some subtle timing problem between two
802 * jobs, we will simply try again, and most likely succeed.
803 * This can happen if one job reserves a drive or finishes using
804 * a drive at the same time a second job wants it.
806 if (repeat++ > 1) { /* try algorithm 3 times */
807 bmicrosleep(30, 0); /* wait a bit */
808 Dmsg0(dbglvl, "repeat reserve algorithm\n");
809 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
810 Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
814 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
816 unlock_reservations();
819 * If we get here, there are no suitable devices available, which
820 * means nothing configured. If a device is suitable but busy
821 * with another Volume, we will not come here.
823 unbash_spaces(dir->msg);
824 pm_strcpy(jcr->errmsg, dir->msg);
825 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
826 Jmsg(jcr, M_FATAL, 0, _("\n"
827 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
828 dev_name.c_str(), media_type.c_str());
829 dir->fsend(NO_device, dev_name.c_str());
831 Dmsg1(dbglvl, ">dird: %s", dir->msg);
834 unbash_spaces(dir->msg);
835 pm_strcpy(jcr->errmsg, dir->msg);
836 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
837 dir->fsend(BAD_use, jcr->errmsg);
838 Dmsg1(dbglvl, ">dird: %s", dir->msg);
841 release_reserve_messages(jcr);
847 * Walk through the autochanger resources and check if
848 * the volume is in one of them.
850 * Returns: true if volume is in device
853 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
855 AUTOCHANGER *changer = vol->dev->device->changer_res;
857 /* Find resource, and make sure we were able to open it */
858 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
859 Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
862 Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
867 * Search for a device suitable for this job.
869 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
878 dirstore = jcr->write_store;
880 dirstore = jcr->read_store;
882 Dmsg4(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
883 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
884 rctx.autochanger_only);
887 * If the appropriate conditions of this if are met, namely that
888 * we are appending and the user wants mounted drive (or we
889 * force try a mounted drive because they are all busy), we
890 * start by looking at all the Volumes in the volume list.
892 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
893 dlist *temp_vol_list, *save_vol_list;
896 Dmsg0(dbglvl, "lock volumes\n");
899 * Create a temporary copy of the volume list. We do this,
900 * to avoid having the volume list locked during the
901 * call to reserve_device(), which would cause a deadlock.
902 * Note, we may want to add an update counter on the vol_list
903 * so that if it is modified while we are traversing the copy
904 * we can take note and act accordingly (probably redo the
905 * search at least a few times).
907 Dmsg0(dbglvl, "duplicate vol list\n");
908 temp_vol_list = New(dlist(vol, &vol->link));
909 foreach_dlist(vol, vol_list) {
911 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
912 memset(tvol, 0, sizeof(VOLRES));
913 tvol->vol_name = bstrdup(vol->vol_name);
914 tvol->dev = vol->dev;
915 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
917 tvol->dev = NULL; /* don't zap dev entry */
919 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
920 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
923 Dmsg0(dbglvl, "unlock volumes\n");
926 /* Look through reserved volumes for one we can use */
927 Dmsg0(dbglvl, "look for vol in vol list\n");
928 foreach_dlist(vol, temp_vol_list) {
930 Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
933 /* Check with Director if this Volume is OK */
934 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
935 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
939 Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
940 foreach_alist(store, dirstore) {
943 foreach_alist(device_name, store->device) {
944 /* Found a device, try to use it */
945 rctx.device_name = device_name;
946 rctx.device = vol->dev->device;
948 if (vol->dev->is_autochanger()) {
949 Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
950 if (!is_vol_in_autochanger(rctx, vol)) {
953 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
954 Dmsg2(dbglvl, "device=%s not suitable want %s\n",
955 vol->dev->device->hdr.name, device_name);
959 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
960 rctx.have_volume = true;
961 /* Try reserving this device and volume */
962 Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
963 stat = reserve_device(rctx);
964 if (stat == 1) { /* found available device */
965 Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
968 } else if (stat == 0) { /* device busy */
969 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
971 /* otherwise error */
972 Dmsg0(dbglvl, "No suitable device found.\n");
974 rctx.have_volume = false;
975 rctx.VolumeName[0] = 0;
984 } /* end for loop over reserved volumes */
986 Dmsg0(dbglvl, "lock volumes\n");
988 save_vol_list = vol_list;
989 vol_list = temp_vol_list;
990 free_volume_list(); /* release temp_vol_list */
991 vol_list = save_vol_list;
992 Dmsg0(dbglvl, "deleted temp vol list\n");
993 Dmsg0(dbglvl, "unlock volumes\n");
995 debug_list_volumes("=== After free temp table\n");
998 Dmsg1(dbglvl, "got vol %s from in-use vols list\n", rctx.VolumeName);
1003 * No reserved volume we can use, so now search for an available device.
1005 * For each storage device that the user specified, we
1006 * search and see if there is a resource for that device.
1008 foreach_alist(store, dirstore) {
1010 foreach_alist(device_name, store->device) {
1012 rctx.device_name = device_name;
1013 stat = search_res_for_device(rctx);
1014 if (stat == 1) { /* found available device */
1015 Dmsg1(dbglvl, "available device found=%s\n", device_name);
1018 } else if (stat == 0) { /* device busy */
1019 Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
1021 /* otherwise error */
1022 Dmsg0(dbglvl, "No suitable device found.\n");
1033 * Search for a particular storage device with particular storage
1034 * characteristics (MediaType).
1036 int search_res_for_device(RCTX &rctx)
1038 AUTOCHANGER *changer;
1041 Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
1042 /* Look through Autochangers first */
1043 foreach_res(changer, R_AUTOCHANGER) {
1044 Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
1045 /* Find resource, and make sure we were able to open it */
1046 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1047 /* Try each device in this AutoChanger */
1048 foreach_alist(rctx.device, changer->device) {
1049 Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
1050 stat = reserve_device(rctx);
1051 if (stat != 1) { /* try another device */
1055 if (rctx.store->append == SD_APPEND) {
1056 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1057 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1059 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1060 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1067 /* Now if requested look through regular devices */
1068 if (!rctx.autochanger_only) {
1069 foreach_res(rctx.device, R_DEVICE) {
1070 Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
1071 /* Find resource, and make sure we were able to open it */
1072 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1073 stat = reserve_device(rctx);
1074 if (stat != 1) { /* try another device */
1078 if (rctx.store->append == SD_APPEND) {
1079 Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
1080 rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device);
1082 Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
1083 rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device);
1089 return -1; /* nothing found */
1093 * Try to reserve a specific device.
1095 * Returns: 1 -- OK, have DCR
1099 static int reserve_device(RCTX &rctx)
1103 const int name_len = MAX_NAME_LENGTH;
1105 /* Make sure MediaType is OK */
1106 Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
1107 rctx.device->media_type, rctx.store->media_type);
1108 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1112 /* Make sure device exists -- i.e. we can stat() it */
1113 if (!rctx.device->dev) {
1114 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1116 if (!rctx.device->dev) {
1117 if (rctx.device->changer_res) {
1118 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1119 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1120 rctx.device->hdr.name, rctx.device_name);
1122 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1123 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1126 return -1; /* no use waiting */
1129 rctx.suitable_device = true;
1130 Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
1131 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1133 BSOCK *dir = rctx.jcr->dir_bsock;
1134 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1135 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1138 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1139 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1140 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1141 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1142 if (rctx.store->append == SD_APPEND) {
1143 Dmsg2(dbglvl, "call reserve for append: have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
1144 ok = reserve_device_for_append(dcr, rctx);
1149 rctx.jcr->dcr = dcr;
1150 Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1151 dcr->dev->reserved_device,
1152 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1153 Dmsg3(dbglvl, "Vol=%s num_writers=%d, have_vol=%d\n",
1154 rctx.VolumeName, dcr->dev->num_writers, rctx.have_volume);
1155 if (rctx.have_volume) {
1156 if (reserve_volume(dcr, rctx.VolumeName)) {
1157 Dmsg1(dbglvl, "Reserved vol=%s\n", rctx.VolumeName);
1159 Dmsg1(dbglvl, "Could not reserve vol=%s\n", rctx.VolumeName);
1163 dcr->any_volume = true;
1164 Dmsg0(dbglvl, "no vol, call find_next_appendable_vol.\n");
1165 if (dir_find_next_appendable_volume(dcr)) {
1166 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1167 rctx.have_volume = true;
1168 Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
1170 Dmsg0(dbglvl, "No next volume found\n");
1171 rctx.have_volume = false;
1172 rctx.VolumeName[0] = 0;
1174 * If there is at least one volume that is valid and in use,
1175 * but we get here, check if we are running with prefers
1176 * non-mounted drives. In that case, we have selected a
1177 * non-used drive and our one and only volume is mounted
1178 * elsewhere, so we bail out and retry using that drive.
1180 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1181 rctx.PreferMountedVols = true;
1182 if (dcr->VolumeName[0]) {
1183 unreserve_device(dcr);
1188 * Note. Under some circumstances, the Director can hand us
1189 * a Volume name that is not the same as the one on the current
1190 * drive, and in that case, the call above to find the next
1191 * volume will fail because in attempting to reserve the Volume
1192 * the code will realize that we already have a tape mounted,
1193 * and it will fail. This *should* only happen if there are
1194 * writers, thus the following test. In that case, we simply
1195 * bail out, and continue waiting, rather than plunging on
1196 * and hoping that the operator can resolve the problem.
1198 if (dcr->dev->num_writers != 0) {
1199 if (dcr->VolumeName[0]) {
1200 unreserve_device(dcr);
1207 ok = reserve_device_for_read(dcr);
1209 rctx.jcr->read_dcr = dcr;
1210 Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1211 dcr->dev->reserved_device,
1212 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1219 if (rctx.notify_dir) {
1221 BSOCK *dir = rctx.jcr->dir_bsock;
1222 pm_strcpy(dev_name, rctx.device->hdr.name);
1223 bash_spaces(dev_name);
1224 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1225 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1232 rctx.have_volume = false;
1233 rctx.VolumeName[0] = 0;
1234 Dmsg0(dbglvl, "Not OK.\n");
1239 * We "reserve" the drive by setting the ST_READ bit. No one else
1240 * should touch the drive until that is cleared.
1241 * This allows the DIR to "reserve" the device before actually
1244 static bool reserve_device_for_read(DCR *dcr)
1246 DEVICE *dev = dcr->dev;
1247 JCR *jcr = dcr->jcr;
1254 if (is_device_unmounted(dev)) {
1255 Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
1256 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1257 jcr->JobId, dev->print_name());
1258 queue_reserve_message(jcr);
1262 if (dev->is_busy()) {
1263 Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1265 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1266 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1267 jcr->JobId, dev->print_name());
1268 queue_reserve_message(jcr);
1272 dev->clear_append();
1275 dev->reserved_device++;
1276 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev);
1277 dcr->reserved_device = true;
1286 * We reserve the device for appending by incrementing the
1287 * reserved_device. We do virtually all the same work that
1288 * is done in acquire_device_for_append(), but we do
1289 * not attempt to mount the device. This routine allows
1290 * the DIR to reserve multiple devices before *really*
1291 * starting the job. It also permits the SD to refuse
1292 * certain devices (not up, ...).
1294 * Note, in reserving a device, if the device is for the
1295 * same pool and the same pool type, then it is acceptable.
1296 * The Media Type has already been checked. If we are
1297 * the first tor reserve the device, we put the pool
1298 * name and pool type in the device record.
1300 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1302 JCR *jcr = dcr->jcr;
1303 DEVICE *dev = dcr->dev;
1310 /* If device is being read, we cannot write it */
1311 if (dev->can_read()) {
1312 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1313 jcr->JobId, dev->print_name());
1314 Dmsg1(dbglvl, "%s", jcr->errmsg);
1315 queue_reserve_message(jcr);
1319 /* If device is unmounted, we are out of luck */
1320 if (is_device_unmounted(dev)) {
1321 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1322 jcr->JobId, dev->print_name());
1323 Dmsg1(dbglvl, "%s", jcr->errmsg);
1324 queue_reserve_message(jcr);
1328 Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
1330 /* Now do detailed tests ... */
1331 if (can_reserve_drive(dcr, rctx) != 1) {
1332 Dmsg0(dbglvl, "can_reserve_drive!=1\n");
1336 dev->reserved_device++;
1337 Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device,
1338 dev->print_name(), dev);
1339 dcr->reserved_device = true;
1347 static int is_pool_ok(DCR *dcr)
1349 DEVICE *dev = dcr->dev;
1350 JCR *jcr = dcr->jcr;
1352 /* Now check if we want the same Pool and pool type */
1353 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1354 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1355 /* OK, compatible device */
1356 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1359 /* Drive Pool not suitable for us */
1360 Mmsg(jcr->errmsg, _(
1361 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1362 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1363 dev->reserved_device, dev->print_name());
1364 queue_reserve_message(jcr);
1365 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1366 dev->pool_name, dcr->pool_name);
1371 static bool is_max_jobs_ok(DCR *dcr)
1373 DEVICE *dev = dcr->dev;
1374 JCR *jcr = dcr->jcr;
1376 Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n",
1377 dcr->VolCatInfo.VolCatMaxJobs,
1378 dcr->VolCatInfo.VolCatJobs, dev->reserved_device,
1380 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1381 (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) {
1382 /* Max Job Vols depassed or already reserved */
1383 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1384 (uint32_t)jcr->JobId, dev->print_name());
1385 queue_reserve_message(jcr);
1386 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1387 return false; /* wait */
1393 * Returns: 1 if drive can be reserved
1394 * 0 if we should wait
1395 * -1 on error or impossibility
1397 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1399 DEVICE *dev = dcr->dev;
1400 JCR *jcr = dcr->jcr;
1402 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1403 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1404 rctx.autochanger_only, rctx.any_drive);
1406 /* Check for max jobs on this Volume */
1407 if (!is_max_jobs_ok(dcr)) {
1411 /* setting any_drive overrides PreferMountedVols flag */
1412 if (!rctx.any_drive) {
1414 * When PreferMountedVols is set, we keep track of the
1415 * drive in use that has the least number of writers, then if
1416 * no unmounted drive is found, we try that drive. This
1417 * helps spread the load to the least used drives.
1419 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1420 Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
1421 dev->print_name(), rctx.low_use_drive->print_name());
1424 /* If he wants a free drive, but this one is busy, no go */
1425 if (!rctx.PreferMountedVols && dev->is_busy()) {
1426 /* Save least used drive */
1427 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1428 rctx.num_writers = dev->num_writers + dev->reserved_device;
1429 rctx.low_use_drive = dev;
1430 Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
1431 dev->print_name(), rctx.num_writers);
1433 Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->reserved_device);
1435 Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
1436 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1437 jcr->JobId, dev->print_name());
1438 queue_reserve_message(jcr);
1442 /* Check for prefer mounted volumes */
1443 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1444 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1445 jcr->JobId, dev->print_name());
1446 queue_reserve_message(jcr);
1447 Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
1448 return 0; /* No volume mounted */
1451 /* Check for exact Volume name match */
1452 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1455 if (rctx.exact_match && rctx.have_volume) {
1457 Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1458 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1459 rctx.autochanger_only, rctx.any_drive);
1460 Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
1461 rctx.have_volume, dev->VolHdr.VolumeName,
1462 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1463 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1464 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1466 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1467 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1469 queue_reserve_message(jcr);
1470 Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
1471 dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1474 if (is_volume_in_use(dcr)) {
1475 return 0; /* fail if volume on another drive */
1480 /* Check for unused autochanger drive */
1481 if (rctx.autochanger_only && !dev->is_busy() &&
1482 dev->VolHdr.VolumeName[0] == 0) {
1483 /* Device is available but not yet reserved, reserve it for us */
1484 Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1485 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1486 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1487 return 1; /* reserve drive */
1491 * Handle the case that there are no writers
1493 if (dev->num_writers == 0) {
1494 /* Now check if there are any reservations on the drive */
1495 if (dev->reserved_device) {
1496 return is_pool_ok(dcr);
1497 } else if (dev->can_append()) {
1498 if (is_pool_ok(dcr)) {
1501 /* Changing pool, unload old tape if any in drive */
1502 Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1503 unload_autochanger(dcr, 0);
1506 /* Device is available but not yet reserved, reserve it for us */
1507 Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1508 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1509 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1510 return 1; /* reserve drive */
1514 * Check if the device is in append mode with writers (i.e.
1515 * available if pool is the same).
1517 if (dev->can_append() || dev->num_writers > 0) {
1518 return is_pool_ok(dcr);
1520 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1521 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1522 jcr->JobId, dev->print_name());
1523 queue_reserve_message(jcr);
1524 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1525 return -1; /* error, should not get here */
1527 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1528 jcr->JobId, dev->print_name());
1529 queue_reserve_message(jcr);
1530 Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1538 * Queue a reservation error or failure message for this jcr
1540 static void queue_reserve_message(JCR *jcr)
1548 msgs = jcr->reserve_msgs;
1553 * Look for duplicate message. If found, do
1556 for (i=msgs->size()-1; i >= 0; i--) {
1557 msg = (char *)msgs->get(i);
1561 /* Comparison based on 4 digit message number */
1562 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1566 /* Message unique, so insert it */
1567 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1574 * Send any reservation messages queued for this jcr
1576 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1583 msgs = jcr->reserve_msgs;
1584 if (!msgs || msgs->size() == 0) {
1587 for (i=msgs->size()-1; i >= 0; i--) {
1588 msg = (char *)msgs->get(i);
1590 sendit(" ", 3, arg);
1591 sendit(msg, strlen(msg), arg);
1602 * Pop and release any reservations messages
1604 static void pop_reserve_messages(JCR *jcr)
1610 msgs = jcr->reserve_msgs;
1614 while ((msg = (char *)msgs->pop())) {
1622 * Also called from acquire.c
1624 void release_reserve_messages(JCR *jcr)
1626 pop_reserve_messages(jcr);
1628 if (!jcr->reserve_msgs) {
1631 delete jcr->reserve_msgs;
1632 jcr->reserve_msgs = NULL;