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 #define jid() ((int)get_jobid_from_tid())
44 const int dbglvl = 50;
46 static dlist *vol_list = NULL;
47 static brwlock_t reservation_lock;
48 static brwlock_t vol_list_lock;
50 /* Forward referenced functions */
51 static int can_reserve_drive(DCR *dcr, RCTX &rctx);
52 static int reserve_device(RCTX &rctx);
53 static bool reserve_device_for_read(DCR *dcr);
54 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx);
55 static bool use_storage_cmd(JCR *jcr);
56 static void queue_reserve_message(JCR *jcr);
57 static void pop_reserve_messages(JCR *jcr);
59 /* Requests from the Director daemon */
60 static char use_storage[] = "use storage=%127s media_type=%127s "
61 "pool_name=%127s pool_type=%127s append=%d copy=%d stripe=%d\n";
62 static char use_device[] = "use device=%127s\n";
64 /* Responses sent to Director daemon */
65 static char OK_device[] = "3000 OK use device device=%s\n";
66 static char NO_device[] = "3924 Device \"%s\" not in SD Device resources.\n";
67 static char BAD_use[] = "3913 Bad use command: %s\n";
69 bool use_cmd(JCR *jcr)
72 * Get the device, media, and pool information
74 if (!use_storage_cmd(jcr)) {
75 set_jcr_job_status(jcr, JS_ErrorTerminated);
76 memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
82 static int my_compare(void *item1, void *item2)
84 return strcmp(((VOLRES *)item1)->vol_name, ((VOLRES *)item2)->vol_name);
88 void init_reservations_lock()
91 if ((errstat=rwl_init(&reservation_lock)) != 0) {
93 Emsg1(M_ABORT, 0, _("Unable to initialize reservation lock. ERR=%s\n"),
94 be.bstrerror(errstat));
97 if ((errstat=rwl_init(&vol_list_lock)) != 0) {
99 Emsg1(M_ABORT, 0, _("Unable to initialize volume list lock. ERR=%s\n"),
100 be.bstrerror(errstat));
104 void term_reservations_lock()
106 rwl_destroy(&reservation_lock);
107 rwl_destroy(&vol_list_lock);
110 int reservations_lock_count = 0;
112 /* This applies to a drive and to Volumes */
113 void _lock_reservations()
116 reservations_lock_count++;
117 if ((errstat=rwl_writelock(&reservation_lock)) != 0) {
119 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
120 errstat, be.bstrerror(errstat));
124 void _unlock_reservations()
127 reservations_lock_count--;
128 if ((errstat=rwl_writeunlock(&reservation_lock)) != 0) {
130 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
131 errstat, be.bstrerror(errstat));
135 int vol_list_lock_count = 0;
140 vol_list_lock_count++;
141 if ((errstat=rwl_writelock(&vol_list_lock)) != 0) {
143 Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
144 errstat, be.bstrerror(errstat));
148 void _unlock_volumes()
151 vol_list_lock_count--;
152 if ((errstat=rwl_writeunlock(&vol_list_lock)) != 0) {
154 Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
155 errstat, be.bstrerror(errstat));
161 * List Volumes -- this should be moved to status.c
168 static void debug_list_volumes(const char *imsg)
171 POOL_MEM msg(PM_MESSAGE);
174 foreach_dlist(vol, vol_list) {
176 Mmsg(msg, "List from %s: %s at %p on device %s\n", imsg,
177 vol->vol_name, vol->vol_name, vol->dev->print_name());
179 Mmsg(msg, "List from %s: %s at %p no dev\n", imsg, vol->vol_name, vol->vol_name);
181 Dmsg2(dbglvl, "jid=%u %s", jid(), msg.c_str());
186 foreach_dlist(vol, vol_list) {
187 if (vol->dev == dev) {
188 Dmsg0(000, "Two Volumes on same device.\n");
195 // Dmsg2(dbglvl, "List from %s: %d volumes\n", imsg, count);
201 * List Volumes -- this should be moved to status.c
203 void list_volumes(void sendit(const char *msg, int len, void *sarg), void *arg)
206 POOL_MEM msg(PM_MESSAGE);
210 foreach_dlist(vol, vol_list) {
211 DEVICE *dev = vol->dev;
213 len = Mmsg(msg, "%s on device %s\n", vol->vol_name, dev->print_name());
214 sendit(msg.c_str(), len, arg);
215 len = Mmsg(msg, " Reader=%d writers=%d reserved=%d released=%d\n",
216 dev->can_read()?1:0, dev->num_writers, dev->reserved_device, vol->released);
217 sendit(msg.c_str(), len, arg);
219 len = Mmsg(msg, "%s no device. released=%d\n", vol->vol_name, vol->released);
220 sendit(msg.c_str(), len, arg);
227 * Create a Volume item to put in the Volume list
228 * Ensure that the device points to it.
230 static VOLRES *new_vol_item(DCR *dcr, const char *VolumeName)
233 vol = (VOLRES *)malloc(sizeof(VOLRES));
234 memset(vol, 0, sizeof(VOLRES));
235 vol->vol_name = bstrdup(VolumeName);
237 Dmsg4(dbglvl, "jid=%u new Vol=%s at %p dev=%s\n", (int)dcr->jcr->JobId,
238 VolumeName, vol->vol_name, vol->dev->print_name());
242 static void free_vol_item(VOLRES *vol)
246 vol->dev->vol = NULL;
253 * Put a new Volume entry in the Volume list. This
254 * effectively reserves the volume so that it will
255 * not be mounted again.
257 * If the device has any current volume associated with it,
258 * and it is a different Volume, and the device is not busy,
259 * we release the old Volume item and insert the new one.
261 * It is assumed that the device is free and locked so that
262 * we can change the device structure.
264 * Some details of the Volume list handling:
266 * 1. The Volume list entry must be attached to the drive (rather than
267 * attached to a job as it currently is. I.e. the drive that "owns"
268 * the volume (reserved, in use, mounted)
269 * must point to the volume (still to be maintained in a list).
271 * 2. The Volume is entered in the list when a drive is reserved.
273 * 3. When a drive is in use, the device code must appropriately update the
274 * volume name as it changes (currently the list is static -- an entry is
275 * removed when the Volume is no longer reserved, in use or mounted).
276 * The new code must keep the same list entry as long as the drive
277 * has any volume associated with it but the volume name in the list
278 * must be updated when the drive has a different volume mounted.
280 * 4. A job that has reserved a volume, can un-reserve the volume, and if the
281 * volume is not mounted, and not reserved, and not in use, it will be
282 * removed from the list.
284 * 5. If a job wants to reserve a drive with a different Volume from the one on
285 * the drive, it can re-use the drive for the new Volume.
287 * 6. If a job wants a Volume that is in a different drive, it can either use the
288 * other drive or take the volume, only if the other drive is not in use or
291 * One nice aspect of this is that the reserve use count and the writer use count
292 * already exist and are correctly programmed and will need no changes -- use
293 * counts are always very tricky.
295 * The old code had a concept of "reserving" a Volume, but was changed
296 * to reserving and using a drive. A volume is must be attached to (owned by) a
297 * drive and can move from drive to drive or be unused given certain specific
298 * conditions of the drive. The key is that the drive must "own" the Volume.
299 * The old code had the job (dcr) owning the volume (more or less). The job was
300 * to change the insertion and removal of the volumes from the list to be based
301 * on the drive rather than the job.
303 * Return: VOLRES entry on success
304 * NULL volume busy on another drive
306 VOLRES *reserve_volume(DCR *dcr, const char *VolumeName)
309 DEVICE *dev = dcr->dev;
313 Dmsg2(dbglvl, "jid=%u reserve_volume %s\n", jid(), VolumeName);
315 * We lock the reservations system here to ensure
316 * when adding a new volume that no newly scheduled
317 * job can reserve it.
320 debug_list_volumes("begin reserve_volume");
322 * First, remove any old volume attached to this device as it
327 Dmsg5(dbglvl, "jid=%u Vol attached=%s, newvol=%s release=%d on %s\n",
328 jid(), vol->vol_name, VolumeName, vol->released, dev->print_name());
330 * Make sure we don't remove the current volume we are inserting
331 * because it was probably inserted by another job, or it
332 * is not being used and is marked as released.
334 if (strcmp(vol->vol_name, VolumeName) == 0) {
335 Dmsg2(dbglvl, "jid=%u === OK, vol=%s on device. set not released.\n", jid(), VolumeName);
336 vol->released = false; /* retake vol if released previously */
337 goto get_out; /* Volume already on this device */
339 /* Don't release a volume if it is in use */
340 if (!vol->released) {
341 Dmsg2(dbglvl, "jid=%u Cannot free vol=%s. It is not released.\n", jid(), vol->vol_name);
342 vol = NULL; /* vol in use */
345 Dmsg3(dbglvl, "jid=%u reserve_vol free vol=%s at %p\n", jid(), vol->vol_name, vol->vol_name);
346 unload_autochanger(dcr, -1); /* unload the volume */
348 debug_list_volumes("reserve_vol free");
352 /* Create a new Volume entry */
353 nvol = new_vol_item(dcr, VolumeName);
356 * Now try to insert the new Volume
358 vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
360 Dmsg3(dbglvl, "jid=%u Found vol=%s dev-same=%d\n", jid(), vol->vol_name, dev==vol->dev);
362 * At this point, a Volume with this name already is in the list,
363 * so we simply release our new Volume entry. Note, this should
364 * only happen if we are moving the volume from one drive to another.
366 Dmsg3(dbglvl, "jid=%u reserve_vol free-tmp vol=%s at %p\n",
367 (int)dcr->jcr->JobId, vol->vol_name, vol->vol_name);
369 * Clear dev pointer so that free_vol_item() doesn't
370 * take away our volume.
372 nvol->dev = NULL; /* don't zap dev entry */
375 /* Check if we are trying to use the Volume on a different drive */
376 if (dev != vol->dev) {
377 /* Caller wants to switch Volume to another device */
378 if (!vol->dev->is_busy()) {
379 /* OK to move it -- I'm not sure this will work */
380 Dmsg4(dbglvl, "==== jid=%u Swap vol=%s from dev=%s to %s\n", jid(), VolumeName,
381 vol->dev->print_name(), dev->print_name());
382 vol->dev->vol = NULL; /* take vol from old drive */
383 vol->dev->VolHdr.VolumeName[0] = 0;
384 vol->dev = dev; /* point vol at new drive */
385 dev->vol = vol; /* point dev at vol */
386 dev->VolHdr.VolumeName[0] = 0;
388 Dmsg4(dbglvl, "jid=%u Volume busy could not swap vol=%s from dev=%s to %s\n",
389 jid(), VolumeName, vol->dev->print_name(), dev->print_name());
390 vol = NULL; /* device busy */
399 Dmsg2(dbglvl, "jid=%u === set not released. vol=%s\n", jid(), vol->vol_name);
400 vol->released = false;
402 debug_list_volumes("end new volume");
408 * Switch from current device to given device
411 void switch_device(DCR *dcr, DEVICE *dev)
413 // lock_reservations();
417 memcpy(&save_dcr, dcr, sizeof(save_dcr));
418 clean_device(dcr); /* clean up the dcr */
420 dcr->dev = dev; /* get new device pointer */
421 Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"),
422 dcr->dev->print_name());
424 bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName));
425 bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type));
426 dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot;
427 bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name));
428 bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type));
429 bstrncpy(dcr->dev_name, dev->dev_name, sizeof(dcr->dev_name));
431 dev->reserved_device++;
432 dcr->reserved_device = true;
438 * Search for a Volume name in the Volume list.
440 * Returns: VOLRES entry on success
441 * NULL if the Volume is not in the list
443 VOLRES *find_volume(DCR *dcr)
446 /* Do not lock reservations here */
448 vol.vol_name = bstrdup(dcr->VolumeName);
449 fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
451 Dmsg3(dbglvl, "jid=%u find_vol=%s found=%d\n", jid(), dcr->VolumeName, fvol!=NULL);
452 debug_list_volumes("find_volume");
458 * Remove any reservation from a drive and tell the system
459 * that the volume is unused at least by us.
461 void unreserve_device(DCR *dcr)
463 DEVICE *dev = dcr->dev;
464 if (dcr->reserved_device) {
465 dcr->reserved_device = false;
466 dev->reserved_device--;
467 Dmsg3(dbglvl, "jid=%u Dec reserve=%d dev=%s\n", jid(), dev->reserved_device, dev->print_name());
468 dcr->reserved_device = false;
469 /* If we set read mode in reserving, remove it */
470 if (dev->can_read()) {
473 if (dev->num_writers < 0) {
474 Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
475 dev->num_writers = 0;
477 if (dev->reserved_device == 0 && dev->num_writers == 0) {
484 * Free a Volume from the Volume list if it is no longer used
485 * Note, for tape drives we want to remember where the Volume
486 * was when last used, so rather than free the volume entry,
487 * we simply mark it "released" so when the drive is really
488 * needed for another volume, we can reuse it.
490 * Returns: true if the Volume found and "removed" from the list
491 * false if the Volume is not in the list or is in use
493 bool volume_unused(DCR *dcr)
495 DEVICE *dev = dcr->dev;
497 if (dev->vol == NULL) {
498 Dmsg2(dbglvl, "jid=%u vol_unused: no vol on %s\n", (int)dcr->jcr->JobId, dev->print_name());
499 debug_list_volumes("null vol cannot unreserve_volume");
504 if (dev->is_busy()) {
505 Dmsg2(dbglvl, "jid=%u vol_unused: no vol on %s\n", (int)dcr->jcr->JobId, dev->print_name());
506 debug_list_volumes("dev busy cannot unreserve_volume");
511 if (dev->num_writers > 0 || dev->reserved_device > 0) {
517 * If this is a tape, we do not free the volume, rather we wait
518 * until the autoloader unloads it, or until another tape is
519 * explicitly read in this drive. This allows the SD to remember
520 * where the tapes are or last were.
522 dev->vol->released = true;
523 if (dev->is_tape()) { // || dev->is_autochanger()) {
527 * Note, this frees the volume reservation entry, but the
528 * file descriptor remains open with the OS.
530 return free_volume(dev);
535 * Unconditionally release the volume entry
537 bool free_volume(DEVICE *dev)
541 if (dev->vol == NULL) {
542 Dmsg2(dbglvl, "jid=%u No vol on dev %s\n", jid(), dev->print_name());
548 vol_list->remove(vol);
549 Dmsg3(dbglvl, "jid=%u free_volume %s dev=%s\n", jid(), vol->vol_name, dev->print_name());
551 debug_list_volumes("free_volume");
557 /* Create the Volume list */
558 void create_volume_list()
561 if (vol_list == NULL) {
562 vol_list = New(dlist(vol, &vol->link));
566 /* Release all Volumes from the list */
567 void free_volume_list()
574 foreach_dlist(vol, vol_list) {
576 Dmsg3(dbglvl, "jid=%u free vol_list Volume=%s dev=%s\n", jid(),
577 vol->vol_name, vol->dev->print_name());
579 Dmsg3(dbglvl, "jid=%u free vol_list Volume=%s dev=%p\n", jid(),
580 vol->vol_name, vol->dev);
583 vol->vol_name = NULL;
590 bool is_volume_in_use(DCR *dcr)
592 VOLRES *vol = find_volume(dcr);
594 Dmsg2(dbglvl, "jid=%u Vol=%s not in use.\n", jid(), dcr->VolumeName);
595 return false; /* vol not in list */
597 ASSERT(vol->dev != NULL);
599 if (dcr->dev == vol->dev) { /* same device OK */
600 Dmsg2(dbglvl, "jid=%u Vol=%s on same dev.\n", jid(), dcr->VolumeName);
603 Dmsg4(dbglvl, "jid=%u Vol=%s on %s we have %s\n", jid(), dcr->VolumeName,
604 vol->dev->print_name(), dcr->dev->print_name());
606 if (!vol->dev->is_busy()) {
607 Dmsg3(dbglvl, "jid=%u Vol=%s dev=%s not busy.\n", jid(), dcr->VolumeName, vol->dev->print_name());
610 Dmsg3(dbglvl, "jid=%u Vol=%s dev=%s busy.\n", jid(), dcr->VolumeName, vol->dev->print_name());
612 Dmsg3(dbglvl, "jid=%u Vol=%s in use by %s.\n", jid(), dcr->VolumeName, vol->dev->print_name());
618 * We get the following type of information:
620 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
624 * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
628 static bool use_storage_cmd(JCR *jcr)
630 POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
631 BSOCK *dir = jcr->dir_bsock;
639 memset(&rctx, 0, sizeof(RCTX));
642 * If there are multiple devices, the director sends us
643 * use_device for each device that it wants to use.
645 dirstore = New(alist(10, not_owned_by_alist));
646 jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
648 Dmsg2(dbglvl, "jid=%u <dird: %s", jid(), dir->msg);
649 ok = sscanf(dir->msg, use_storage, store_name.c_str(),
650 media_type.c_str(), pool_name.c_str(),
651 pool_type.c_str(), &append, &Copy, &Stripe) == 7;
656 jcr->write_store = dirstore;
658 jcr->read_store = dirstore;
660 rctx.append = append;
661 unbash_spaces(store_name);
662 unbash_spaces(media_type);
663 unbash_spaces(pool_name);
664 unbash_spaces(pool_type);
665 store = new DIRSTORE;
666 dirstore->append(store);
667 memset(store, 0, sizeof(DIRSTORE));
668 store->device = New(alist(10));
669 bstrncpy(store->name, store_name, sizeof(store->name));
670 bstrncpy(store->media_type, media_type, sizeof(store->media_type));
671 bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
672 bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
673 store->append = append;
675 /* Now get all devices */
676 while (dir->recv() >= 0) {
677 Dmsg2(dbglvl, "jid=%u <dird device: %s", jid(), dir->msg);
678 ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
682 unbash_spaces(dev_name);
683 store->device->append(bstrdup(dev_name.c_str()));
685 } while (ok && dir->recv() >= 0);
687 /* Developer debug code */
689 if (debug_level >= dbglvl) {
690 foreach_alist(store, dirstore) {
691 Dmsg6(dbglvl, "jid=%u Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
692 (int)rctx.jcr->JobId,
693 store->name, store->media_type, store->pool_name,
694 store->pool_type, store->append);
695 foreach_alist(device_name, store->device) {
696 Dmsg2(dbglvl, "jid=%u Device=%s\n", jid(), 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 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
743 (int)rctx.jcr->JobId,
744 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
745 rctx.autochanger_only, rctx.any_drive);
746 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
749 /* Look through all drives possibly for low_use drive */
750 if (rctx.low_use_drive) {
751 rctx.try_low_use_drive = true;
752 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
755 rctx.try_low_use_drive = false;
757 rctx.autochanger_only = false;
758 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
759 (int)rctx.jcr->JobId,
760 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
761 rctx.autochanger_only, rctx.any_drive);
762 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
767 * Now we look for a drive that may or may not be in
770 /* Look for an exact Volume match all drives */
771 rctx.PreferMountedVols = true;
772 rctx.exact_match = true;
773 rctx.autochanger_only = false;
774 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
775 (int)rctx.jcr->JobId,
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 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
784 (int)rctx.jcr->JobId,
785 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
786 rctx.autochanger_only, rctx.any_drive);
787 if ((ok = find_suitable_device_for_job(jcr, rctx))) {
791 rctx.any_drive = true;
792 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
793 (int)rctx.jcr->JobId,
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))) {
799 /* Keep reservations locked *except* during wait_for_device() */
800 unlock_reservations();
802 * The idea of looping on repeat a few times it to ensure
803 * that if there is some subtle timing problem between two
804 * jobs, we will simply try again, and most likely succeed.
805 * This can happen if one job reserves a drive or finishes using
806 * a drive at the same time a second job wants it.
808 if (repeat++ > 1) { /* try algorithm 3 times */
809 bmicrosleep(30, 0); /* wait a bit */
810 Dmsg1(dbglvl, "jid=%u repeat reserve algorithm\n", (int)rctx.jcr->JobId);
811 } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
812 Dmsg1(dbglvl, "jid=%u Fail. !suitable_device || !wait_for_device\n",
813 (int)rctx.jcr->JobId);
817 dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */
819 unlock_reservations();
822 * If we get here, there are no suitable devices available, which
823 * means nothing configured. If a device is suitable but busy
824 * with another Volume, we will not come here.
826 unbash_spaces(dir->msg);
827 pm_strcpy(jcr->errmsg, dir->msg);
828 Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
829 Jmsg(jcr, M_FATAL, 0, _("\n"
830 " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
831 dev_name.c_str(), media_type.c_str());
832 dir->fsend(NO_device, dev_name.c_str());
834 Dmsg2(dbglvl, "jid=%u >dird: %s", jid(), dir->msg);
837 unbash_spaces(dir->msg);
838 pm_strcpy(jcr->errmsg, dir->msg);
839 Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
840 dir->fsend(BAD_use, jcr->errmsg);
841 Dmsg2(dbglvl, "jid=%u >dird: %s", jid(), dir->msg);
844 release_reserve_messages(jcr);
850 * Walk through the autochanger resources and check if
851 * the volume is in one of them.
853 * Returns: true if volume is in device
856 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
858 AUTOCHANGER *changer = vol->dev->device->changer_res;
860 /* Find resource, and make sure we were able to open it */
861 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
862 Dmsg2(dbglvl, "jid=%u Found changer device %s\n",
863 (int)rctx.jcr->JobId, vol->dev->device->hdr.name);
866 Dmsg2(dbglvl, "jid=%u Incorrect changer device %s\n",
867 (int)rctx.jcr->JobId, changer->hdr.name);
872 * Search for a device suitable for this job.
874 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
883 dirstore = jcr->write_store;
885 dirstore = jcr->read_store;
887 Dmsg5(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
888 (int)rctx.jcr->JobId,
889 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
890 rctx.autochanger_only);
893 * If the appropriate conditions of this if are met, namely that
894 * we are appending and the user wants mounted drive (or we
895 * force try a mounted drive because they are all busy), we
896 * start by looking at all the Volumes in the volume list.
898 if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
899 dlist *temp_vol_list, *save_vol_list;
902 Dmsg0(dbglvl, "lock volumes\n");
905 * Create a temporary copy of the volume list. We do this,
906 * to avoid having the volume list locked during the
907 * call to reserve_device(), which would cause a deadlock.
908 * Note, we may want to add an update counter on the vol_list
909 * so that if it is modified while we are traversing the copy
910 * we can take note and act accordingly (probably redo the
911 * search at least a few times).
913 Dmsg1(dbglvl, "jid=%u duplicate vol list\n", (int)rctx.jcr->JobId);
914 temp_vol_list = New(dlist(vol, &vol->link));
915 foreach_dlist(vol, vol_list) {
917 VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
918 memset(tvol, 0, sizeof(VOLRES));
919 tvol->vol_name = bstrdup(vol->vol_name);
920 tvol->dev = vol->dev;
921 nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
923 tvol->dev = NULL; /* don't zap dev entry */
925 Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
926 Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
931 /* Look through reserved volumes for one we can use */
932 Dmsg1(dbglvl, "jid=%u look for vol in vol list\n", (int)rctx.jcr->JobId);
933 foreach_dlist(vol, temp_vol_list) {
935 Dmsg2(dbglvl, "jid=%u vol=%s no dev\n", (int)rctx.jcr->JobId, vol->vol_name);
938 /* Check with Director if this Volume is OK */
939 bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
940 if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
944 Dmsg2(dbglvl, "jid=%u vol=%s OK for this job\n", (int)rctx.jcr->JobId, vol->vol_name);
945 foreach_alist(store, dirstore) {
948 foreach_alist(device_name, store->device) {
949 /* Found a device, try to use it */
950 rctx.device_name = device_name;
951 rctx.device = vol->dev->device;
953 if (vol->dev->is_autochanger()) {
954 Dmsg2(dbglvl, "jid=%u vol=%s is in changer\n", (int)rctx.jcr->JobId,
956 if (!is_vol_in_autochanger(rctx, vol)) {
959 } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
960 Dmsg3(dbglvl, "jid=%u device=%s not suitable want %s\n", (int)rctx.jcr->JobId,
961 vol->dev->device->hdr.name, device_name);
965 bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
966 rctx.have_volume = true;
967 /* Try reserving this device and volume */
968 Dmsg3(dbglvl, "jid=%u try vol=%s on device=%s\n", (int)rctx.jcr->JobId,
969 rctx.VolumeName, device_name);
970 stat = reserve_device(rctx);
971 if (stat == 1) { /* found available device */
972 Dmsg2(dbglvl, "jid=%u Suitable device found=%s\n", (int)rctx.jcr->JobId,
976 } else if (stat == 0) { /* device busy */
977 Dmsg2(dbglvl, "jid=%u Suitable device=%s, busy: not use\n",
978 (int)rctx.jcr->JobId, device_name);
980 /* otherwise error */
981 Dmsg1(dbglvl, "jid=%u No suitable device found.\n", (int)rctx.jcr->JobId);
983 rctx.have_volume = false;
984 rctx.VolumeName[0] = 0;
993 } /* end for loop over reserved volumes */
995 Dmsg1(dbglvl, "%u lock volumes\n", jid());
997 save_vol_list = vol_list;
998 vol_list = temp_vol_list;
999 free_volume_list(); /* release temp_vol_list */
1000 vol_list = save_vol_list;
1001 Dmsg1(dbglvl, "jid=%u deleted temp vol list\n", (int)rctx.jcr->JobId);
1002 Dmsg1(dbglvl, "jid=%u unlock volumes\n", (int)rctx.jcr->JobId);
1006 Dmsg2(dbglvl, "jid=%u got vol %s from in-use vols list\n", (int)rctx.jcr->JobId,
1012 * No reserved volume we can use, so now search for an available device.
1014 * For each storage device that the user specified, we
1015 * search and see if there is a resource for that device.
1017 foreach_alist(store, dirstore) {
1019 foreach_alist(device_name, store->device) {
1021 rctx.device_name = device_name;
1022 stat = search_res_for_device(rctx);
1023 if (stat == 1) { /* found available device */
1024 Dmsg2(dbglvl, "jid=%u available device found=%s\n", (int)rctx.jcr->JobId,
1028 } else if (stat == 0) { /* device busy */
1029 Dmsg2(dbglvl, "jid=%u Suitable device=%s, busy: not use\n",
1030 (int)rctx.jcr->JobId, device_name);
1032 /* otherwise error */
1033 Dmsg1(dbglvl, "jid=%u No suitable device found.\n", (int)rctx.jcr->JobId);
1044 * Search for a particular storage device with particular storage
1045 * characteristics (MediaType).
1047 int search_res_for_device(RCTX &rctx)
1049 AUTOCHANGER *changer;
1052 Dmsg2(dbglvl, "jid=%u search res for %s\n", (int)rctx.jcr->JobId, rctx.device_name);
1053 /* Look through Autochangers first */
1054 foreach_res(changer, R_AUTOCHANGER) {
1055 Dmsg2(dbglvl, "jid=%u Try match changer res=%s\n", (int)rctx.jcr->JobId, changer->hdr.name);
1056 /* Find resource, and make sure we were able to open it */
1057 if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
1058 /* Try each device in this AutoChanger */
1059 foreach_alist(rctx.device, changer->device) {
1060 Dmsg2(dbglvl, "jid=%u Try changer device %s\n", (int)rctx.jcr->JobId,
1061 rctx.device->hdr.name);
1062 stat = reserve_device(rctx);
1063 if (stat != 1) { /* try another device */
1067 if (rctx.store->append == SD_APPEND) {
1068 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for append.\n",
1069 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1070 rctx.jcr->dcr->dev->reserved_device);
1072 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for read.\n",
1073 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1074 rctx.jcr->read_dcr->dev->reserved_device);
1081 /* Now if requested look through regular devices */
1082 if (!rctx.autochanger_only) {
1083 foreach_res(rctx.device, R_DEVICE) {
1084 Dmsg2(dbglvl, "jid=%u Try match res=%s\n", (int)rctx.jcr->JobId, rctx.device->hdr.name);
1085 /* Find resource, and make sure we were able to open it */
1086 if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
1087 stat = reserve_device(rctx);
1088 if (stat != 1) { /* try another device */
1092 if (rctx.store->append == SD_APPEND) {
1093 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for append.\n",
1094 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1095 rctx.jcr->dcr->dev->reserved_device);
1097 Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for read.\n",
1098 (int)rctx.jcr->JobId, rctx.device->hdr.name,
1099 rctx.jcr->read_dcr->dev->reserved_device);
1105 return -1; /* nothing found */
1109 * Try to reserve a specific device.
1111 * Returns: 1 -- OK, have DCR
1115 static int reserve_device(RCTX &rctx)
1119 const int name_len = MAX_NAME_LENGTH;
1121 /* Make sure MediaType is OK */
1122 Dmsg3(dbglvl, "jid=%u chk MediaType device=%s request=%s\n",
1123 (int)rctx.jcr->JobId,
1124 rctx.device->media_type, rctx.store->media_type);
1125 if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1129 /* Make sure device exists -- i.e. we can stat() it */
1130 if (!rctx.device->dev) {
1131 rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1133 if (!rctx.device->dev) {
1134 if (rctx.device->changer_res) {
1135 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1136 " Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1137 rctx.device->hdr.name, rctx.device_name);
1139 Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1140 " Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1143 return -1; /* no use waiting */
1146 rctx.suitable_device = true;
1147 Dmsg2(dbglvl, "jid=%u try reserve %s\n", rctx.jcr->JobId, rctx.device->hdr.name);
1148 rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1150 BSOCK *dir = rctx.jcr->dir_bsock;
1151 dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1152 Dmsg1(dbglvl, ">dird: %s", dir->msg);
1155 bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1156 bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1157 bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1158 bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1159 if (rctx.store->append == SD_APPEND) {
1160 Dmsg3(dbglvl, "jid=%u have_vol=%d vol=%s\n", (int)rctx.jcr->JobId,
1161 rctx.have_volume, rctx.VolumeName);
1162 ok = reserve_device_for_append(dcr, rctx);
1167 rctx.jcr->dcr = dcr;
1168 Dmsg6(dbglvl, "jid=%u Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1169 (int)rctx.jcr->JobId,
1170 dcr->dev->reserved_device,
1171 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1172 if (rctx.have_volume) {
1173 if (reserve_volume(dcr, rctx.VolumeName)) {
1174 Dmsg2(dbglvl, "jid=%u Reserved vol=%s\n", jid(), rctx.VolumeName);
1176 Dmsg2(dbglvl, "jid=%u Could not reserve vol=%s\n", jid(), rctx.VolumeName);
1180 dcr->any_volume = true;
1181 if (dir_find_next_appendable_volume(dcr)) {
1182 bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1183 Dmsg2(dbglvl, "jid=%u looking for Volume=%s\n", (int)rctx.jcr->JobId, rctx.VolumeName);
1184 rctx.have_volume = true;
1186 Dmsg1(dbglvl, "jid=%u No next volume found\n", (int)rctx.jcr->JobId);
1187 rctx.have_volume = false;
1188 rctx.VolumeName[0] = 0;
1190 * If there is at least one volume that is valid and in use,
1191 * but we get here, check if we are running with prefers
1192 * non-mounted drives. In that case, we have selected a
1193 * non-used drive and our one and only volume is mounted
1194 * elsewhere, so we bail out and retry using that drive.
1196 if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1197 rctx.PreferMountedVols = true;
1198 if (dcr->VolumeName[0]) {
1199 unreserve_device(dcr);
1204 * Note. Under some circumstances, the Director can hand us
1205 * a Volume name that is not the same as the one on the current
1206 * drive, and in that case, the call above to find the next
1207 * volume will fail because in attempting to reserve the Volume
1208 * the code will realize that we already have a tape mounted,
1209 * and it will fail. This *should* only happen if there are
1210 * writers, thus the following test. In that case, we simply
1211 * bail out, and continue waiting, rather than plunging on
1212 * and hoping that the operator can resolve the problem.
1214 if (dcr->dev->num_writers != 0) {
1215 if (dcr->VolumeName[0]) {
1216 unreserve_device(dcr);
1223 ok = reserve_device_for_read(dcr);
1225 rctx.jcr->read_dcr = dcr;
1226 Dmsg6(dbglvl, "jid=%u Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1227 (int)rctx.jcr->JobId,
1228 dcr->dev->reserved_device,
1229 dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1236 if (rctx.notify_dir) {
1238 BSOCK *dir = rctx.jcr->dir_bsock;
1239 pm_strcpy(dev_name, rctx.device->hdr.name);
1240 bash_spaces(dev_name);
1241 ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */
1242 Dmsg2(dbglvl, "jid=%u >dird changer: %s", jid(), dir->msg);
1249 rctx.have_volume = false;
1250 Dmsg1(dbglvl, "jid=%u Not OK.\n", (int)rctx.jcr->JobId);
1251 rctx.VolumeName[0] = 0;
1256 * We "reserve" the drive by setting the ST_READ bit. No one else
1257 * should touch the drive until that is cleared.
1258 * This allows the DIR to "reserve" the device before actually
1261 static bool reserve_device_for_read(DCR *dcr)
1263 DEVICE *dev = dcr->dev;
1264 JCR *jcr = dcr->jcr;
1271 if (is_device_unmounted(dev)) {
1272 Dmsg2(dbglvl, "jid=%u Device %s is BLOCKED due to user unmount.\n",
1273 (int)jcr->JobId, dev->print_name());
1274 Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1275 jcr->JobId, dev->print_name());
1276 queue_reserve_message(jcr);
1280 if (dev->is_busy()) {
1281 Dmsg5(dbglvl, "jid=%u Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1282 (int)jcr->JobId, dev->print_name(),
1283 dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1284 Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1285 jcr->JobId, dev->print_name());
1286 queue_reserve_message(jcr);
1290 dev->clear_append();
1293 dev->reserved_device++;
1294 Dmsg4(dbglvl, "jid=%u Inc reserve=%d dev=%s %p\n", (int)jcr->JobId,
1295 dev->reserved_device, dev->print_name(), dev);
1296 dcr->reserved_device = true;
1305 * We reserve the device for appending by incrementing the
1306 * reserved_device. We do virtually all the same work that
1307 * is done in acquire_device_for_append(), but we do
1308 * not attempt to mount the device. This routine allows
1309 * the DIR to reserve multiple devices before *really*
1310 * starting the job. It also permits the SD to refuse
1311 * certain devices (not up, ...).
1313 * Note, in reserving a device, if the device is for the
1314 * same pool and the same pool type, then it is acceptable.
1315 * The Media Type has already been checked. If we are
1316 * the first tor reserve the device, we put the pool
1317 * name and pool type in the device record.
1319 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1321 JCR *jcr = dcr->jcr;
1322 DEVICE *dev = dcr->dev;
1329 /* If device is being read, we cannot write it */
1330 if (dev->can_read()) {
1331 Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1332 jcr->JobId, dev->print_name());
1333 Dmsg2(dbglvl, "jid=%u %s", jid(), jcr->errmsg);
1334 queue_reserve_message(jcr);
1338 /* If device is unmounted, we are out of luck */
1339 if (is_device_unmounted(dev)) {
1340 Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1341 jcr->JobId, dev->print_name());
1342 Dmsg2(dbglvl, "jid=%u %s", jid(), jcr->errmsg);
1343 queue_reserve_message(jcr);
1347 Dmsg2(dbglvl, "jid=%u reserve_append device is %s\n",
1348 (int)jcr->JobId, dev->print_name());
1350 /* Now do detailed tests ... */
1351 if (can_reserve_drive(dcr, rctx) != 1) {
1352 Dmsg1(dbglvl, "jid=%u can_reserve_drive!=1\n", (int)jcr->JobId);
1356 dev->reserved_device++;
1357 Dmsg4(dbglvl, "jid=%u Inc reserve=%d dev=%s %p\n", (int)jcr->JobId, dev->reserved_device,
1358 dev->print_name(), dev);
1359 dcr->reserved_device = true;
1367 static int is_pool_ok(DCR *dcr)
1369 DEVICE *dev = dcr->dev;
1370 JCR *jcr = dcr->jcr;
1372 /* Now check if we want the same Pool and pool type */
1373 if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1374 strcmp(dev->pool_type, dcr->pool_type) == 0) {
1375 /* OK, compatible device */
1376 Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
1379 /* Drive Pool not suitable for us */
1380 Mmsg(jcr->errmsg, _(
1381 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1382 (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
1383 dev->reserved_device, dev->print_name());
1384 queue_reserve_message(jcr);
1385 Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1386 dev->pool_name, dcr->pool_name);
1391 static bool is_max_jobs_ok(DCR *dcr)
1393 DEVICE *dev = dcr->dev;
1394 JCR *jcr = dcr->jcr;
1396 Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n",
1397 dcr->VolCatInfo.VolCatMaxJobs,
1398 dcr->VolCatInfo.VolCatJobs, dev->reserved_device,
1400 if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
1401 (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) {
1402 /* Max Job Vols depassed or already reserved */
1403 Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
1404 (uint32_t)jcr->JobId, dev->print_name());
1405 queue_reserve_message(jcr);
1406 Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
1407 return false; /* wait */
1413 * Returns: 1 if drive can be reserved
1414 * 0 if we should wait
1415 * -1 on error or impossibility
1417 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1419 DEVICE *dev = dcr->dev;
1420 JCR *jcr = dcr->jcr;
1422 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1424 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1425 rctx.autochanger_only, rctx.any_drive);
1427 /* Check for max jobs on this Volume */
1428 if (!is_max_jobs_ok(dcr)) {
1432 /* setting any_drive overrides PreferMountedVols flag */
1433 if (!rctx.any_drive) {
1435 * When PreferMountedVols is set, we keep track of the
1436 * drive in use that has the least number of writers, then if
1437 * no unmounted drive is found, we try that drive. This
1438 * helps spread the load to the least used drives.
1440 if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1441 Dmsg3(dbglvl, "jid=%u OK dev=%s == low_drive=%s.\n",
1442 jcr->JobId, dev->print_name(), rctx.low_use_drive->print_name());
1445 /* If he wants a free drive, but this one is busy, no go */
1446 if (!rctx.PreferMountedVols && dev->is_busy()) {
1447 /* Save least used drive */
1448 if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1449 rctx.num_writers = dev->num_writers + dev->reserved_device;
1450 rctx.low_use_drive = dev;
1451 Dmsg3(dbglvl, "jid=%u set low use drive=%s num_writers=%d\n",
1452 (int)jcr->JobId, dev->print_name(), rctx.num_writers);
1454 Dmsg2(dbglvl, "jid=%u not low use num_writers=%d\n",
1455 (int)jcr->JobId, dev->num_writers+dev->reserved_device);
1457 Dmsg1(dbglvl, "jid=%u failed: !prefMnt && busy.\n", jcr->JobId);
1458 Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1459 jcr->JobId, dev->print_name());
1460 queue_reserve_message(jcr);
1464 /* Check for prefer mounted volumes */
1465 if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1466 Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1467 jcr->JobId, dev->print_name());
1468 queue_reserve_message(jcr);
1469 Dmsg1(dbglvl, "jid=%u failed: want mounted -- no vol\n", (uint32_t)jcr->JobId);
1470 return 0; /* No volume mounted */
1473 /* Check for exact Volume name match */
1474 /* ***FIXME*** for Disk, we can accept any volume that goes with this
1477 if (rctx.exact_match && rctx.have_volume) {
1479 Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1481 rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1482 rctx.autochanger_only, rctx.any_drive);
1483 Dmsg5(dbglvl, "jid=%u have_vol=%d have=%s resvol=%s want=%s\n",
1484 (int)jcr->JobId, rctx.have_volume, dev->VolHdr.VolumeName,
1485 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1486 ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1487 (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1489 Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1490 jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1492 queue_reserve_message(jcr);
1493 Dmsg4(dbglvl, "jid=%u not OK: dev have=%s resvol=%s want=%s\n",
1494 (int)jcr->JobId, dev->VolHdr.VolumeName,
1495 dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1498 if (is_volume_in_use(dcr)) {
1499 return 0; /* fail if volume on another drive */
1504 /* Check for unused autochanger drive */
1505 if (rctx.autochanger_only && !dev->is_busy() &&
1506 dev->VolHdr.VolumeName[0] == 0) {
1507 /* Device is available but not yet reserved, reserve it for us */
1508 Dmsg2(dbglvl, "jid=%u OK Res Unused autochanger %s.\n",
1509 jcr->JobId, dev->print_name());
1510 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1511 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1512 return 1; /* reserve drive */
1516 * Handle the case that there are no writers
1518 if (dev->num_writers == 0) {
1519 /* Now check if there are any reservations on the drive */
1520 if (dev->reserved_device) {
1521 return is_pool_ok(dcr);
1522 } else if (dev->can_append()) {
1523 if (is_pool_ok(dcr)) {
1526 /* Changing pool, unload old tape if any in drive */
1527 Dmsg1(dbglvl, "jid=%u OK dev: num_writers=0, not reserved, pool change, unload changer\n",
1529 unload_autochanger(dcr, 0);
1532 /* Device is available but not yet reserved, reserve it for us */
1533 Dmsg2(dbglvl, "jid=%u OK Dev avail reserved %s\n", jcr->JobId, dev->print_name());
1534 bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1535 bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1536 return 1; /* reserve drive */
1540 * Check if the device is in append mode with writers (i.e.
1541 * available if pool is the same).
1543 if (dev->can_append() || dev->num_writers > 0) {
1544 return is_pool_ok(dcr);
1546 Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1547 Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1548 jcr->JobId, dev->print_name());
1549 queue_reserve_message(jcr);
1550 Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1551 return -1; /* error, should not get here */
1553 Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1554 jcr->JobId, dev->print_name());
1555 queue_reserve_message(jcr);
1556 Dmsg2(dbglvl, "jid=%u failed: No reserve %s\n", jcr->JobId, dev->print_name());
1564 * Queue a reservation error or failure message for this jcr
1566 static void queue_reserve_message(JCR *jcr)
1574 msgs = jcr->reserve_msgs;
1579 * Look for duplicate message. If found, do
1582 for (i=msgs->size()-1; i >= 0; i--) {
1583 msg = (char *)msgs->get(i);
1587 /* Comparison based on 4 digit message number */
1588 if (strncmp(msg, jcr->errmsg, 4) == 0) {
1592 /* Message unique, so insert it */
1593 jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1600 * Send any reservation messages queued for this jcr
1602 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1609 msgs = jcr->reserve_msgs;
1610 if (!msgs || msgs->size() == 0) {
1613 for (i=msgs->size()-1; i >= 0; i--) {
1614 msg = (char *)msgs->get(i);
1616 sendit(" ", 3, arg);
1617 sendit(msg, strlen(msg), arg);
1628 * Pop and release any reservations messages
1630 static void pop_reserve_messages(JCR *jcr)
1636 msgs = jcr->reserve_msgs;
1640 while ((msg = (char *)msgs->pop())) {
1648 * Also called from acquire.c
1650 void release_reserve_messages(JCR *jcr)
1652 pop_reserve_messages(jcr);
1654 if (!jcr->reserve_msgs) {
1657 delete jcr->reserve_msgs;
1658 jcr->reserve_msgs = NULL;