X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Freserve.c;h=1aafd357f047cf937c00ae1ef08d333a6d7472bc;hb=bc9b9b481e86991abd879d30aa03b64b4c68d578;hp=96d9c4f4d6bc077163399fc9f7b1346621f13119;hpb=90c1a15f09531f81b007d5b5f33914bd3c70aab5;p=bacula%2Fbacula diff --git a/bacula/src/stored/reserve.c b/bacula/src/stored/reserve.c index 96d9c4f4d6..1aafd357f0 100644 --- a/bacula/src/stored/reserve.c +++ b/bacula/src/stored/reserve.c @@ -1,14 +1,14 @@ /* Bacula® - The Network Backup Solution - Copyright (C) 2000-2007 Free Software Foundation Europe e.V. + Copyright (C) 2000-2008 Free Software Foundation Europe e.V. The main author of Bacula is Kern Sibbald, with contributions from many others, a complete list can be found in the file AUTHORS. This program is Free Software; you can redistribute it and/or modify it under the terms of version two of the GNU General Public - License as published by the Free Software Foundation plus additions - that are listed in the file LICENSE. + License as published by the Free Software Foundation and included + in the file LICENSE. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -39,10 +39,11 @@ #include "bacula.h" #include "stored.h" -const int dbglvl = 100; +const int dbglvl = 50; static dlist *vol_list = NULL; -static pthread_mutex_t vol_list_lock = PTHREAD_MUTEX_INITIALIZER; +static brwlock_t reservation_lock; +static brwlock_t vol_list_lock; /* Forward referenced functions */ static int can_reserve_drive(DCR *dcr, RCTX &rctx); @@ -51,6 +52,8 @@ static bool reserve_device_for_read(DCR *dcr); static bool reserve_device_for_append(DCR *dcr, RCTX &rctx); static bool use_storage_cmd(JCR *jcr); static void queue_reserve_message(JCR *jcr); +static void pop_reserve_messages(JCR *jcr); +void switch_device(DCR *dcr, DEVICE *dev); /* Requests from the Director daemon */ static char use_storage[] = "use storage=%127s media_type=%127s " @@ -80,8 +83,10 @@ static int my_compare(void *item1, void *item2) return strcmp(((VOLRES *)item1)->vol_name, ((VOLRES *)item2)->vol_name); } -static brwlock_t reservation_lock; - +/* + * This allows a given thread to recursively call lock_reservations. + * It must, of course, call unlock_... the same number of times. + */ void init_reservations_lock() { int errstat; @@ -91,11 +96,17 @@ void init_reservations_lock() be.bstrerror(errstat)); } + if ((errstat=rwl_init(&vol_list_lock)) != 0) { + berrno be; + Emsg1(M_ABORT, 0, _("Unable to initialize volume list lock. ERR=%s\n"), + be.bstrerror(errstat)); + } } void term_reservations_lock() { rwl_destroy(&reservation_lock); + rwl_destroy(&vol_list_lock); } int reservations_lock_count = 0; @@ -123,6 +134,34 @@ void _unlock_reservations() } } +int vol_list_lock_count = 0; + +/* + * This allows a given thread to recursively call to lock_volumes() + */ +void _lock_volumes() +{ + int errstat; + vol_list_lock_count++; + if ((errstat=rwl_writelock(&vol_list_lock)) != 0) { + berrno be; + Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n", + errstat, be.bstrerror(errstat)); + } +} + +void _unlock_volumes() +{ + int errstat; + vol_list_lock_count--; + if ((errstat=rwl_writeunlock(&vol_list_lock)) != 0) { + berrno be; + Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n", + errstat, be.bstrerror(errstat)); + } +} + + /* * List Volumes -- this should be moved to status.c */ @@ -131,35 +170,35 @@ enum { debug_nolock = false }; -static void debug_list_volumes(const char *imsg, bool do_lock) +static void debug_list_volumes(const char *imsg) { VOLRES *vol; POOL_MEM msg(PM_MESSAGE); - int count = 0; - DEVICE *dev = NULL; - if (do_lock) P(vol_list_lock); - for (vol=(VOLRES *)vol_list->first(); vol; vol=(VOLRES *)vol_list->next(vol)) { + lock_volumes(); + foreach_dlist(vol, vol_list) { if (vol->dev) { - Mmsg(msg, "List from %s: %s at %p on device %s\n", imsg, - vol->vol_name, vol->vol_name, vol->dev->print_name()); + Mmsg(msg, "List %s: %s rel=%d on device %s\n", imsg, + vol->vol_name, vol->released, vol->dev->print_name()); } else { - Mmsg(msg, "List from %s: %s at %p no dev\n", imsg, vol->vol_name, vol->vol_name); + Mmsg(msg, "List %s: %s rel=%d no dev\n", imsg, vol->vol_name, vol->released); } Dmsg1(dbglvl, "%s", msg.c_str()); - count++; } - for (vol=(VOLRES *)vol_list->first(); vol; vol=(VOLRES *)vol_list->next(vol)) { +#ifdef xxx + DEVICE *dev = NULL; + foreach_dlist(vol, vol_list) { if (vol->dev == dev) { - Dmsg0(000, "Two Volumes on same device.\n"); + Dmsg0(dbglvl, "Two Volumes on same device.\n"); ASSERT(0); dev = vol->dev; } } +#endif - Dmsg2(dbglvl, "List from %s: %d volumes\n", imsg, count); - if (do_lock) V(vol_list_lock); +// Dmsg2(dbglvl, "List from %s: %d volumes\n", imsg, count); + unlock_volumes(); } @@ -172,17 +211,21 @@ void list_volumes(void sendit(const char *msg, int len, void *sarg), void *arg) POOL_MEM msg(PM_MESSAGE); int len; - P(vol_list_lock); - for (vol=(VOLRES *)vol_list->first(); vol; vol=(VOLRES *)vol_list->next(vol)) { - if (vol->dev) { - len = Mmsg(msg, "%s on device %s\n", vol->vol_name, vol->dev->print_name()); + lock_volumes(); + foreach_dlist(vol, vol_list) { + DEVICE *dev = vol->dev; + if (dev) { + len = Mmsg(msg, "%s on device %s\n", vol->vol_name, dev->print_name()); + sendit(msg.c_str(), len, arg); + len = Mmsg(msg, " Reader=%d writers=%d reserved=%d released=%d\n", + dev->can_read()?1:0, dev->num_writers, dev->reserved_device, vol->released); sendit(msg.c_str(), len, arg); } else { - len = Mmsg(msg, "%s no dev\n", vol->vol_name); + len = Mmsg(msg, "%s no device. released=%d\n", vol->vol_name, vol->released); sendit(msg.c_str(), len, arg); } } - V(vol_list_lock); + unlock_volumes(); } /* @@ -196,8 +239,8 @@ static VOLRES *new_vol_item(DCR *dcr, const char *VolumeName) memset(vol, 0, sizeof(VOLRES)); vol->vol_name = bstrdup(VolumeName); vol->dev = dcr->dev; - Dmsg4(dbglvl, "New Vol=%s at %p dev=%s JobId=%u\n", VolumeName, vol->vol_name, - vol->dev->print_name(), (int)dcr->jcr->JobId); + Dmsg3(dbglvl, "new Vol=%s at %p dev=%s\n", + VolumeName, vol->vol_name, vol->dev->print_name()); return vol; } @@ -254,11 +297,11 @@ static void free_vol_item(VOLRES *vol) * already exist and are correctly programmed and will need no changes -- use * counts are always very tricky. * - * The old code had a concept of "reserving" a Volume, but it needs to be changed + * The old code had a concept of "reserving" a Volume, but was changed * to reserving and using a drive. A volume is must be attached to (owned by) a * drive and can move from drive to drive or be unused given certain specific * conditions of the drive. The key is that the drive must "own" the Volume. - * The old code has the job (dcr) owning the volume (more or less). The job is + * The old code had the job (dcr) owning the volume (more or less). The job was * to change the insertion and removal of the volumes from the list to be based * on the drive rather than the job. * @@ -268,36 +311,46 @@ static void free_vol_item(VOLRES *vol) VOLRES *reserve_volume(DCR *dcr, const char *VolumeName) { VOLRES *vol, *nvol; - DEVICE *dev = dcr->dev; + DEVICE * volatile dev = dcr->dev; ASSERT(dev != NULL); - Dmsg1(dbglvl, "reserve_volume %s\n", VolumeName); + Dmsg1(dbglvl, "enter reserve_volume %s\n", VolumeName); /* * We lock the reservations system here to ensure * when adding a new volume that no newly scheduled * job can reserve it. */ - P(vol_list_lock); - debug_list_volumes("begin reserve_volume", debug_nolock); + lock_volumes(); + debug_list_volumes("begin reserve_volume"); /* * First, remove any old volume attached to this device as it * is no longer used. */ if (dev->vol) { vol = dev->vol; + Dmsg4(dbglvl, "Vol attached=%s, newvol=%s release=%d on %s\n", + vol->vol_name, VolumeName, vol->released, dev->print_name()); /* * Make sure we don't remove the current volume we are inserting - * because it was probably inserted by another job. + * because it was probably inserted by another job, or it + * is not being used and is marked as released. */ if (strcmp(vol->vol_name, VolumeName) == 0) { + Dmsg1(dbglvl, "=== OK, vol=%s on device. set not released.\n", VolumeName); + vol->released = false; /* retake vol if released previously */ goto get_out; /* Volume already on this device */ } else { - Dmsg3(dbglvl, "reserve_vol free vol=%s at %p JobId=%u\n", vol->vol_name, - vol->vol_name, (int)dcr->jcr->JobId); - debug_list_volumes("reserve_vol free", debug_nolock); - vol_list->remove(vol); - free_vol_item(vol); + /* Don't release a volume if it is in use */ + if (!vol->released) { + Dmsg1(dbglvl, "Cannot free vol=%s. It is not released.\n", vol->vol_name); + vol = NULL; /* vol in use */ + goto get_out; + } + Dmsg2(dbglvl, "reserve_vol free vol=%s at %p\n", vol->vol_name, vol->vol_name); + unload_autochanger(dcr, -1); /* unload the volume */ + free_volume(dev); + debug_list_volumes("reserve_vol free"); } } @@ -315,8 +368,8 @@ VOLRES *reserve_volume(DCR *dcr, const char *VolumeName) * so we simply release our new Volume entry. Note, this should * only happen if we are moving the volume from one drive to another. */ - Dmsg3(dbglvl, "reserve_vol free-tmp vol=%s at %p JobId=%u\n", vol->vol_name, - vol->vol_name, (int)dcr->jcr->JobId); + Dmsg2(dbglvl, "reserve_vol free-tmp vol=%s at %p\n", + vol->vol_name, vol->vol_name); /* * Clear dev pointer so that free_vol_item() doesn't * take away our volume. @@ -327,6 +380,9 @@ VOLRES *reserve_volume(DCR *dcr, const char *VolumeName) /* Check if we are trying to use the Volume on a different drive */ if (dev != vol->dev) { /* Caller wants to switch Volume to another device */ + switch_device(dcr, vol->dev); + dev = vol->dev; +#ifdef xxx if (!vol->dev->is_busy()) { /* OK to move it -- I'm not sure this will work */ Dmsg3(dbglvl, "==== Swap vol=%s from dev=%s to %s\n", VolumeName, @@ -337,37 +393,73 @@ VOLRES *reserve_volume(DCR *dcr, const char *VolumeName) dev->vol = vol; /* point dev at vol */ dev->VolHdr.VolumeName[0] = 0; } else { - Dmsg3(dbglvl, "Volume busy could not swap vol=%s from dev=%s to %s\n", VolumeName, - vol->dev->print_name(), dev->print_name()); + Dmsg3(dbglvl, "==== Swap not possible Vol busy vol=%s from dev=%s to %s\n", + VolumeName, vol->dev->print_name(), dev->print_name()); vol = NULL; /* device busy */ + goto get_out; } +#endif } } dev->vol = vol; get_out: - debug_list_volumes("end new volume", debug_nolock); - V(vol_list_lock); + if (vol) { + Dmsg1(dbglvl, "=== set not released. vol=%s\n", vol->vol_name); + vol->released = false; + } + debug_list_volumes("end new volume"); + unlock_volumes(); return vol; } +/* + * Switch from current device to given device + * (not yet used) + */ +void switch_device(DCR *dcr, DEVICE *dev) +{ + // lock_reservations(); + DCR save_dcr; + + dev->dlock(); + memcpy(&save_dcr, dcr, sizeof(save_dcr)); + clean_device(dcr); /* clean up the dcr */ + + dcr->dev = dev; /* get new device pointer */ + Jmsg(dcr->jcr, M_INFO, 0, _("Device switch. New device %s chosen.\n"), + dcr->dev->print_name()); + + bstrncpy(dcr->VolumeName, save_dcr.VolumeName, sizeof(dcr->VolumeName)); + bstrncpy(dcr->media_type, save_dcr.media_type, sizeof(dcr->media_type)); + dcr->VolCatInfo.Slot = save_dcr.VolCatInfo.Slot; + bstrncpy(dcr->pool_name, save_dcr.pool_name, sizeof(dcr->pool_name)); + bstrncpy(dcr->pool_type, save_dcr.pool_type, sizeof(dcr->pool_type)); + bstrncpy(dcr->dev_name, dev->dev_name, sizeof(dcr->dev_name)); + + dev->reserved_device++; + dcr->reserved_device = true; + + dev->dunlock(); +} + /* * Search for a Volume name in the Volume list. * * Returns: VOLRES entry on success * NULL if the Volume is not in the list */ -VOLRES *find_volume(const char *VolumeName) +VOLRES *find_volume(DCR *dcr) { VOLRES vol, *fvol; /* Do not lock reservations here */ - P(vol_list_lock); - vol.vol_name = bstrdup(VolumeName); + lock_volumes(); + vol.vol_name = bstrdup(dcr->VolumeName); fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare); free(vol.vol_name); - Dmsg2(dbglvl, "find_vol=%s found=%d\n", VolumeName, fvol!=NULL); - debug_list_volumes("find_volume", debug_nolock); - V(vol_list_lock); + Dmsg2(dbglvl, "find_vol=%s found=%d\n", dcr->VolumeName, fvol!=NULL); + debug_list_volumes("find_volume"); + unlock_volumes(); return fvol; } @@ -378,7 +470,6 @@ VOLRES *find_volume(const char *VolumeName) void unreserve_device(DCR *dcr) { DEVICE *dev = dcr->dev; - dev->dlock(); if (dcr->reserved_device) { dcr->reserved_device = false; dev->reserved_device--; @@ -392,16 +483,20 @@ void unreserve_device(DCR *dcr) Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers); dev->num_writers = 0; } + if (dev->reserved_device == 0 && dev->num_writers == 0) { + volume_unused(dcr); + } } - - volume_unused(dcr); - dev->dunlock(); } /* * Free a Volume from the Volume list if it is no longer used + * Note, for tape drives we want to remember where the Volume + * was when last used, so rather than free the volume entry, + * we simply mark it "released" so when the drive is really + * needed for another volume, we can reuse it. * - * Returns: true if the Volume found and removed from the list + * Returns: true if the Volume found and "removed" from the list * false if the Volume is not in the list or is in use */ bool volume_unused(DCR *dcr) @@ -409,22 +504,46 @@ bool volume_unused(DCR *dcr) DEVICE *dev = dcr->dev; if (dev->vol == NULL) { - Dmsg1(dbglvl, " unreserve_volume: no vol on %s\n", dev->print_name()); - debug_list_volumes("null return unreserve_volume", debug_lock); + Dmsg1(dbglvl, "vol_unused: no vol on %s\n", dev->print_name()); + debug_list_volumes("null vol cannot unreserve_volume"); return false; } +#ifdef xxx if (dev->is_busy()) { - Dmsg1(dbglvl, "unreserve_volume: dev is busy %s\n", dev->print_name()); - debug_list_volumes("dev busy return unreserve_volume", debug_lock); + Dmsg1(dbglvl, "vol_unused: busy on %s\n", dev->print_name()); + debug_list_volumes("dev busy cannot unreserve_volume"); return false; } +#endif +#ifdef xxx + if (dev->num_writers > 0 || dev->reserved_device > 0) { + ASSERT(0); + } +#endif - return free_volume(dev); + /* + * If this is a tape, we do not free the volume, rather we wait + * until the autoloader unloads it, or until another tape is + * explicitly read in this drive. This allows the SD to remember + * where the tapes are or last were. + */ + Dmsg3(dbglvl, "=== mark released vol=%s num_writers=%d reserved=%d\n", + dev->vol->vol_name, dev->num_writers, dev->reserved_device); + dev->vol->released = true; + if (dev->is_tape()) { // || dev->is_autochanger()) { + return true; + } else { + /* + * Note, this frees the volume reservation entry, but the + * file descriptor remains open with the OS. + */ + return free_volume(dev); + } } /* - * Unconditionally release the volume + * Unconditionally release the volume entry */ bool free_volume(DEVICE *dev) { @@ -434,16 +553,14 @@ bool free_volume(DEVICE *dev) Dmsg1(dbglvl, "No vol on dev %s\n", dev->print_name()); return false; } - P(vol_list_lock); + lock_volumes(); vol = dev->vol; dev->vol = NULL; - Dmsg1(dbglvl, "free_volume %s\n", vol->vol_name); vol_list->remove(vol); - Dmsg3(dbglvl, "free_volume %s at %p dev=%s\n", vol->vol_name, vol->vol_name, - dev->print_name()); + Dmsg2(dbglvl, "=== free_volume %s dev=%s\n", vol->vol_name, dev->print_name()); free_vol_item(vol); - debug_list_volumes("free_volume", debug_nolock); - V(vol_list_lock); + debug_list_volumes("free_volume"); + unlock_volumes(); return vol != NULL; } @@ -451,9 +568,9 @@ bool free_volume(DEVICE *dev) /* Create the Volume list */ void create_volume_list() { - VOLRES *dummy = NULL; + VOLRES *vol = NULL; if (vol_list == NULL) { - vol_list = New(dlist(dummy, &dummy->link)); + vol_list = New(dlist(vol, &vol->link)); } } @@ -464,20 +581,24 @@ void free_volume_list() if (!vol_list) { return; } - P(vol_list_lock); - for (vol=(VOLRES *)vol_list->first(); vol; vol=(VOLRES *)vol_list->next(vol)) { - Dmsg2(dbglvl, "Unreleased Volume=%s dev=%p\n", vol->vol_name, vol->dev); + lock_volumes(); + foreach_dlist(vol, vol_list) { + if (vol->dev) { + Dmsg2(dbglvl, "free vol_list Volume=%s dev=%s\n", vol->vol_name, vol->dev->print_name()); + } else { + Dmsg1(dbglvl, "free vol_list Volume=%s No dev\n", vol->vol_name); + } free(vol->vol_name); vol->vol_name = NULL; } delete vol_list; vol_list = NULL; - V(vol_list_lock); + unlock_volumes(); } bool is_volume_in_use(DCR *dcr) { - VOLRES *vol = find_volume(dcr->VolumeName); + VOLRES *vol = find_volume(dcr); if (!vol) { Dmsg1(dbglvl, "Vol=%s not in use.\n", dcr->VolumeName); return false; /* vol not in list */ @@ -522,8 +643,6 @@ static bool use_storage_cmd(JCR *jcr) int Copy, Stripe; DIRSTORE *store; RCTX rctx; - char *msg; - alist *msgs; alist *dirstore; memset(&rctx, 0, sizeof(RCTX)); @@ -533,7 +652,7 @@ static bool use_storage_cmd(JCR *jcr) * use_device for each device that it wants to use. */ dirstore = New(alist(10, not_owned_by_alist)); - msgs = jcr->reserve_msgs = New(alist(10, not_owned_by_alist)); + jcr->reserve_msgs = New(alist(10, not_owned_by_alist)); do { Dmsg1(dbglvl, "msg); ok = sscanf(dir->msg, use_storage, store_name.c_str(), @@ -574,22 +693,27 @@ static bool use_storage_cmd(JCR *jcr) } } while (ok && dir->recv() >= 0); -#ifdef DEVELOPER - /* This loop is debug code and can be removed */ - /* ***FIXME**** remove after 1.38 release */ + /* Developer debug code */ char *device_name; - foreach_alist(store, dirstore) { - Dmsg6(dbglvl, "JobId=%u Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n", - (int)rctx.jcr->JobId, - store->name, store->media_type, store->pool_name, - store->pool_type, store->append); - foreach_alist(device_name, store->device) { - Dmsg1(dbglvl, " Device=%s\n", device_name); + if (debug_level >= dbglvl) { + foreach_alist(store, dirstore) { + Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n", + store->name, store->media_type, store->pool_name, + store->pool_type, store->append); + foreach_alist(device_name, store->device) { + Dmsg1(dbglvl, " Device=%s\n", device_name); + } } } -#endif init_jcr_device_wait_timers(jcr); + jcr->dcr = new_dcr(jcr, NULL, NULL); /* get a dcr */ + if (!jcr->dcr) { + BSOCK *dir = jcr->dir_bsock; + dir->fsend(_("3939 Could not get dcr\n")); + Dmsg1(dbglvl, ">dird: %s", dir->msg); + ok = false; + } /* * At this point, we have a list of all the Director's Storage * resources indicated for this Job, which include Pool, PoolType, @@ -600,28 +724,30 @@ static bool use_storage_cmd(JCR *jcr) * Wiffle through them and find one that can do the backup. */ if (ok) { - int retries = 0; /* wait for device retries */ + int wait_for_device_retries = 0; int repeat = 0; bool fail = false; rctx.notify_dir = true; + lock_reservations(); for ( ; !fail && !job_canceled(jcr); ) { - while ((msg = (char *)msgs->pop())) { - free(msg); - } + pop_reserve_messages(jcr); rctx.suitable_device = false; rctx.have_volume = false; rctx.VolumeName[0] = 0; rctx.any_drive = false; if (!jcr->PreferMountedVols) { - /* Look for unused drives in autochangers */ + /* + * Here we try to find a drive that is not used. + * This will maximize the use of available drives. + * + */ rctx.num_writers = 20000000; /* start with impossible number */ rctx.low_use_drive = NULL; rctx.PreferMountedVols = false; rctx.exact_match = false; rctx.autochanger_only = true; - Dmsg6(dbglvl, "JobId=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", - (int)rctx.jcr->JobId, + Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device, rctx.autochanger_only, rctx.any_drive); if ((ok = find_suitable_device_for_job(jcr, rctx))) { @@ -636,20 +762,22 @@ static bool use_storage_cmd(JCR *jcr) rctx.try_low_use_drive = false; } rctx.autochanger_only = false; - Dmsg6(dbglvl, "JobId=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", - (int)rctx.jcr->JobId, + Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device, rctx.autochanger_only, rctx.any_drive); if ((ok = find_suitable_device_for_job(jcr, rctx))) { break; } } - /* Look for an exact match all drives */ + /* + * Now we look for a drive that may or may not be in + * use. + */ + /* Look for an exact Volume match all drives */ rctx.PreferMountedVols = true; rctx.exact_match = true; rctx.autochanger_only = false; - Dmsg6(dbglvl, "JobId=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", - (int)rctx.jcr->JobId, + Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device, rctx.autochanger_only, rctx.any_drive); if ((ok = find_suitable_device_for_job(jcr, rctx))) { @@ -657,8 +785,7 @@ static bool use_storage_cmd(JCR *jcr) } /* Look for any mounted drive */ rctx.exact_match = false; - Dmsg6(dbglvl, "JobId=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", - (int)rctx.jcr->JobId, + Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device, rctx.autochanger_only, rctx.any_drive); if ((ok = find_suitable_device_for_job(jcr, rctx))) { @@ -666,8 +793,7 @@ static bool use_storage_cmd(JCR *jcr) } /* Try any drive */ rctx.any_drive = true; - Dmsg6(dbglvl, "JobId=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", - (int)rctx.jcr->JobId, + Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device, rctx.autochanger_only, rctx.any_drive); if ((ok = find_suitable_device_for_job(jcr, rctx))) { @@ -684,13 +810,13 @@ static bool use_storage_cmd(JCR *jcr) */ if (repeat++ > 1) { /* try algorithm 3 times */ bmicrosleep(30, 0); /* wait a bit */ - } else if (!rctx.suitable_device || !wait_for_device(jcr, retries)) { - Dmsg1(dbglvl, "JobId=%u Fail. !suitable_device || !wait_for_device\n", - (int)rctx.jcr->JobId); + Dmsg0(dbglvl, "repeat reserve algorithm\n"); + } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) { + Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n"); fail = true; } lock_reservations(); - bnet_sig(dir, BNET_HEARTBEAT); /* Inform Dir that we are alive */ + dir->signal(BNET_HEARTBEAT); /* Inform Dir that we are alive */ } unlock_reservations(); if (!ok) { @@ -705,7 +831,7 @@ static bool use_storage_cmd(JCR *jcr) Jmsg(jcr, M_FATAL, 0, _("\n" " Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"), dev_name.c_str(), media_type.c_str()); - bnet_fsend(dir, NO_device, dev_name.c_str()); + dir->fsend(NO_device, dev_name.c_str()); Dmsg1(dbglvl, ">dird: %s", dir->msg); } @@ -713,29 +839,33 @@ static bool use_storage_cmd(JCR *jcr) unbash_spaces(dir->msg); pm_strcpy(jcr->errmsg, dir->msg); Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg); - bnet_fsend(dir, BAD_use, jcr->errmsg); + dir->fsend(BAD_use, jcr->errmsg); Dmsg1(dbglvl, ">dird: %s", dir->msg); } - release_msgs(jcr); + release_reserve_messages(jcr); return ok; } -void release_msgs(JCR *jcr) + +/* + * Walk through the autochanger resources and check if + * the volume is in one of them. + * + * Returns: true if volume is in device + * false otherwise + */ +static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol) { - alist *msgs = jcr->reserve_msgs; - char *msg; + AUTOCHANGER *changer = vol->dev->device->changer_res; - if (!msgs) { - return; - } - lock_reservations(); - while ((msg = (char *)msgs->pop())) { - free(msg); - } - delete msgs; - jcr->reserve_msgs = NULL; - unlock_reservations(); + /* Find resource, and make sure we were able to open it */ + if (strcmp(rctx.device_name, changer->hdr.name) == 0) { + Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name); + return true; + } + Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name); + return false; } /* @@ -743,25 +873,143 @@ void release_msgs(JCR *jcr) */ bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx) { - bool ok; + bool ok = false; DIRSTORE *store; char *device_name; alist *dirstore; + DCR *dcr = jcr->dcr; if (rctx.append) { dirstore = jcr->write_store; } else { dirstore = jcr->read_store; } + Dmsg4(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d\n", + rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device, + rctx.autochanger_only); + /* + * If the appropriate conditions of this if are met, namely that + * we are appending and the user wants mounted drive (or we + * force try a mounted drive because they are all busy), we + * start by looking at all the Volumes in the volume list. + */ + if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) { + dlist *temp_vol_list, *save_vol_list; + VOLRES *vol = NULL; + lock_volumes(); + Dmsg0(dbglvl, "lock volumes\n"); + + /* + * Create a temporary copy of the volume list. We do this, + * to avoid having the volume list locked during the + * call to reserve_device(), which would cause a deadlock. + * Note, we may want to add an update counter on the vol_list + * so that if it is modified while we are traversing the copy + * we can take note and act accordingly (probably redo the + * search at least a few times). + */ + Dmsg0(dbglvl, "duplicate vol list\n"); + temp_vol_list = New(dlist(vol, &vol->link)); + foreach_dlist(vol, vol_list) { + VOLRES *nvol; + VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES)); + memset(tvol, 0, sizeof(VOLRES)); + tvol->vol_name = bstrdup(vol->vol_name); + tvol->dev = vol->dev; + nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare); + if (tvol != nvol) { + tvol->dev = NULL; /* don't zap dev entry */ + free_vol_item(tvol); + Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n"); + Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n"); + } + } + Dmsg0(dbglvl, "unlock volumes\n"); + unlock_volumes(); + + /* Look through reserved volumes for one we can use */ + Dmsg0(dbglvl, "look for vol in vol list\n"); + foreach_dlist(vol, temp_vol_list) { + if (!vol->dev) { + Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name); + continue; + } + /* Check with Director if this Volume is OK */ + bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName)); + if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) { + continue; + } + + Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name); + foreach_alist(store, dirstore) { + int stat; + rctx.store = store; + foreach_alist(device_name, store->device) { + /* Found a device, try to use it */ + rctx.device_name = device_name; + rctx.device = vol->dev->device; + + if (vol->dev->is_autochanger()) { + Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name); + if (!is_vol_in_autochanger(rctx, vol)) { + continue; + } + } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) { + Dmsg2(dbglvl, "device=%s not suitable want %s\n", + vol->dev->device->hdr.name, device_name); + continue; + } + + bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName)); + rctx.have_volume = true; + /* Try reserving this device and volume */ + Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name); + stat = reserve_device(rctx); + if (stat == 1) { /* found available device */ + Dmsg1(dbglvl, "Suitable device found=%s\n", device_name); + ok = true; + break; + } else if (stat == 0) { /* device busy */ + Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name); + } else { + /* otherwise error */ + Dmsg0(dbglvl, "No suitable device found.\n"); + } + rctx.have_volume = false; + rctx.VolumeName[0] = 0; + } + if (ok) { + break; + } + } + if (ok) { + break; + } + } /* end for loop over reserved volumes */ + + Dmsg0(dbglvl, "lock volumes\n"); + lock_volumes(); + save_vol_list = vol_list; + vol_list = temp_vol_list; + free_volume_list(); /* release temp_vol_list */ + vol_list = save_vol_list; + Dmsg0(dbglvl, "deleted temp vol list\n"); + Dmsg0(dbglvl, "unlock volumes\n"); + unlock_volumes(); + debug_list_volumes("=== After free temp table\n"); + } + if (ok) { + Dmsg1(dbglvl, "got vol %s from in-use vols list\n", rctx.VolumeName); + return true; + } + + /* + * No reserved volume we can use, so now search for an available device. + * * For each storage device that the user specified, we * search and see if there is a resource for that device. */ - Dmsg5(dbglvl, "JobId=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d\n", - (int)rctx.jcr->JobId, - rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device, - rctx.autochanger_only); - ok = false; foreach_alist(store, dirstore) { rctx.store = store; foreach_alist(device_name, store->device) { @@ -769,16 +1017,14 @@ bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx) rctx.device_name = device_name; stat = search_res_for_device(rctx); if (stat == 1) { /* found available device */ - Dmsg2(dbglvl, "JobId=%u Suitable device found=%s\n", (int)rctx.jcr->JobId, - device_name); + Dmsg1(dbglvl, "available device found=%s\n", device_name); ok = true; break; } else if (stat == 0) { /* device busy */ - Dmsg2(dbglvl, "JobId=%u Suitable device=%s, busy: not use\n", - (int)rctx.jcr->JobId, device_name); + Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name); } else { /* otherwise error */ - Dmsg1(dbglvl, "JobId=%u No suitable device found.\n", (int)rctx.jcr->JobId); + Dmsg0(dbglvl, "No suitable device found.\n"); } } if (ok) { @@ -795,43 +1041,30 @@ bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx) int search_res_for_device(RCTX &rctx) { AUTOCHANGER *changer; - BSOCK *dir = rctx.jcr->dir_bsock; - bool ok; int stat; - Dmsg2(dbglvl, "JobId=%u search res for %s\n", (int)rctx.jcr->JobId, rctx.device_name); + Dmsg1(dbglvl, "search res for %s\n", rctx.device_name); /* Look through Autochangers first */ foreach_res(changer, R_AUTOCHANGER) { - Dmsg2(150, "JobId=%u Try match changer res=%s\n", (int)rctx.jcr->JobId, changer->hdr.name); + Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name); /* Find resource, and make sure we were able to open it */ - if (fnmatch(rctx.device_name, changer->hdr.name, 0) == 0) { + if (strcmp(rctx.device_name, changer->hdr.name) == 0) { /* Try each device in this AutoChanger */ foreach_alist(rctx.device, changer->device) { - Dmsg2(dbglvl, "JobId=%u Try changer device %s\n", (int)rctx.jcr->JobId, - rctx.device->hdr.name); + Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name); stat = reserve_device(rctx); if (stat != 1) { /* try another device */ continue; } - POOL_MEM dev_name; + /* Debug code */ if (rctx.store->append == SD_APPEND) { - Dmsg3(dbglvl, "JobId=%u Device %s reserved=%d for append.\n", - (int)rctx.jcr->JobId, rctx.device->hdr.name, - rctx.jcr->dcr->dev->reserved_device); + Dmsg2(dbglvl, "Device %s reserved=%d for append.\n", + rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device); } else { - Dmsg3(dbglvl, "JobId=%u Device %s reserved=%d for read.\n", - (int)rctx.jcr->JobId, rctx.device->hdr.name, - rctx.jcr->read_dcr->dev->reserved_device); + Dmsg2(dbglvl, "Device %s reserved=%d for read.\n", + rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device); } - if (rctx.notify_dir) { - pm_strcpy(dev_name, rctx.device->hdr.name); - bash_spaces(dev_name); - ok = bnet_fsend(dir, OK_device, dev_name.c_str()); /* Return real device name */ - Dmsg1(dbglvl, ">dird changer: %s", dir->msg); - } else { - ok = true; - } - return ok ? 1 : -1; + return stat; } } } @@ -839,21 +1072,22 @@ int search_res_for_device(RCTX &rctx) /* Now if requested look through regular devices */ if (!rctx.autochanger_only) { foreach_res(rctx.device, R_DEVICE) { - Dmsg2(150, "JobId=%u Try match res=%s\n", (int)rctx.jcr->JobId, rctx.device->hdr.name); + Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name); /* Find resource, and make sure we were able to open it */ - if (fnmatch(rctx.device_name, rctx.device->hdr.name, 0) == 0) { + if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) { stat = reserve_device(rctx); - if (stat != 1) { - return stat; + if (stat != 1) { /* try another device */ + continue; } - if (rctx.notify_dir) { - bash_spaces(rctx.device_name); - ok = bnet_fsend(dir, OK_device, rctx.device_name); - Dmsg1(dbglvl, ">dird dev: %s", dir->msg); + /* Debug code */ + if (rctx.store->append == SD_APPEND) { + Dmsg2(dbglvl, "Device %s reserved=%d for append.\n", + rctx.device->hdr.name, rctx.jcr->dcr->dev->reserved_device); } else { - ok = true; + Dmsg2(dbglvl, "Device %s reserved=%d for read.\n", + rctx.device->hdr.name, rctx.jcr->read_dcr->dev->reserved_device); } - return ok ? 1 : -1; + return stat; } } } @@ -874,8 +1108,7 @@ static int reserve_device(RCTX &rctx) const int name_len = MAX_NAME_LENGTH; /* Make sure MediaType is OK */ - Dmsg3(dbglvl, "JobId=%u MediaType device=%s request=%s\n", - (int)rctx.jcr->JobId, + Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n", rctx.device->media_type, rctx.store->media_type); if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) { return -1; @@ -899,12 +1132,11 @@ static int reserve_device(RCTX &rctx) } rctx.suitable_device = true; - Dmsg2(dbglvl, "Try reserve %s JobId=%u\n", rctx.device->hdr.name, - rctx.jcr->JobId); - dcr = new_dcr(rctx.jcr, rctx.device->dev); + Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name); + rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev); if (!dcr) { BSOCK *dir = rctx.jcr->dir_bsock; - bnet_fsend(dir, _("3926 Could not get dcr for device: %s\n"), rctx.device_name); + dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name); Dmsg1(dbglvl, ">dird: %s", dir->msg); return -1; } @@ -913,45 +1145,99 @@ static int reserve_device(RCTX &rctx) bstrncpy(dcr->media_type, rctx.store->media_type, name_len); bstrncpy(dcr->dev_name, rctx.device_name, name_len); if (rctx.store->append == SD_APPEND) { - Dmsg3(dbglvl, "JobId=%u have_vol=%d vol=%s\n", (int)rctx.jcr->JobId, - rctx.have_volume, rctx.VolumeName); - if (!rctx.have_volume) { + Dmsg2(dbglvl, "call reserve for append: have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName); + ok = reserve_device_for_append(dcr, rctx); + if (!ok) { + goto bail_out; + } + + rctx.jcr->dcr = dcr; + Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n", + dcr->dev->reserved_device, + dcr->dev_name, dcr->media_type, dcr->pool_name, ok); + Dmsg3(dbglvl, "Vol=%s num_writers=%d, have_vol=%d\n", + rctx.VolumeName, dcr->dev->num_writers, rctx.have_volume); + if (rctx.have_volume) { + if (reserve_volume(dcr, rctx.VolumeName)) { + Dmsg1(dbglvl, "Reserved vol=%s\n", rctx.VolumeName); + } else { + Dmsg1(dbglvl, "Could not reserve vol=%s\n", rctx.VolumeName); + goto bail_out; + } + } else { dcr->any_volume = true; + Dmsg0(dbglvl, "no vol, call find_next_appendable_vol.\n"); if (dir_find_next_appendable_volume(dcr)) { bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName)); - Dmsg2(dbglvl, "JobId=%u looking for Volume=%s\n", (int)rctx.jcr->JobId, rctx.VolumeName); rctx.have_volume = true; + Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName); } else { - Dmsg1(dbglvl, "JobId=%u No next volume found\n", (int)rctx.jcr->JobId); + Dmsg0(dbglvl, "No next volume found\n"); rctx.have_volume = false; rctx.VolumeName[0] = 0; - } - } - ok = reserve_device_for_append(dcr, rctx); - if (ok) { - rctx.jcr->dcr = dcr; - Dmsg6(dbglvl, "JobId=%u Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n", - (int)rctx.jcr->JobId, - dcr->dev->reserved_device, - dcr->dev_name, dcr->media_type, dcr->pool_name, ok); + /* + * If there is at least one volume that is valid and in use, + * but we get here, check if we are running with prefers + * non-mounted drives. In that case, we have selected a + * non-used drive and our one and only volume is mounted + * elsewhere, so we bail out and retry using that drive. + */ + if (dcr->volume_in_use && !rctx.PreferMountedVols) { + rctx.PreferMountedVols = true; + if (dcr->VolumeName[0]) { + unreserve_device(dcr); + } + goto bail_out; + } + /* + * Note. Under some circumstances, the Director can hand us + * a Volume name that is not the same as the one on the current + * drive, and in that case, the call above to find the next + * volume will fail because in attempting to reserve the Volume + * the code will realize that we already have a tape mounted, + * and it will fail. This *should* only happen if there are + * writers, thus the following test. In that case, we simply + * bail out, and continue waiting, rather than plunging on + * and hoping that the operator can resolve the problem. + */ + if (dcr->dev->num_writers != 0) { + if (dcr->VolumeName[0]) { + unreserve_device(dcr); + } + goto bail_out; + } + } } } else { ok = reserve_device_for_read(dcr); if (ok) { rctx.jcr->read_dcr = dcr; - Dmsg6(dbglvl, "JobId=%u Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n", - (int)rctx.jcr->JobId, + Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n", dcr->dev->reserved_device, dcr->dev_name, dcr->media_type, dcr->pool_name, ok); } } if (!ok) { - rctx.have_volume = false; - free_dcr(dcr); - Dmsg1(dbglvl, "JobId=%u Not OK.\n", (int)rctx.jcr->JobId); - return 0; + goto bail_out; } - return 1; + + if (rctx.notify_dir) { + POOL_MEM dev_name; + BSOCK *dir = rctx.jcr->dir_bsock; + pm_strcpy(dev_name, rctx.device->hdr.name); + bash_spaces(dev_name); + ok = dir->fsend(OK_device, dev_name.c_str()); /* Return real device name */ + Dmsg1(dbglvl, ">dird: %s", dir->msg); + } else { + ok = true; + } + return ok ? 1 : -1; + +bail_out: + rctx.have_volume = false; + rctx.VolumeName[0] = 0; + Dmsg0(dbglvl, "Not OK.\n"); + return 0; } /* @@ -971,8 +1257,7 @@ static bool reserve_device_for_read(DCR *dcr) dev->dlock(); if (is_device_unmounted(dev)) { - Dmsg2(dbglvl, "JobId=%u Device %s is BLOCKED due to user unmount.\n", - (int)jcr->JobId, dev->print_name()); + Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name()); Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"), jcr->JobId, dev->print_name()); queue_reserve_message(jcr); @@ -980,8 +1265,8 @@ static bool reserve_device_for_read(DCR *dcr) } if (dev->is_busy()) { - Dmsg5(dbglvl, "JobId=%u Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n", - (int)jcr->JobId, dev->print_name(), + Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n", + dev->print_name(), dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device); Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"), jcr->JobId, dev->print_name()); @@ -993,8 +1278,7 @@ static bool reserve_device_for_read(DCR *dcr) dev->set_read(); ok = true; dev->reserved_device++; - Dmsg4(dbglvl, "JobId=%u Inc reserve=%d dev=%s %p\n", (int)jcr->JobId, - dev->reserved_device, dev->print_name(), dev); + Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev); dcr->reserved_device = true; bail_out: @@ -1046,17 +1330,16 @@ static bool reserve_device_for_append(DCR *dcr, RCTX &rctx) goto bail_out; } - Dmsg2(dbglvl, "JobId=%u reserve_append device is %s\n", - (int)jcr->JobId, dev->print_name()); + Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name()); /* Now do detailed tests ... */ if (can_reserve_drive(dcr, rctx) != 1) { - Dmsg1(dbglvl, "JobId=%u can_reserve_drive!=1\n", (int)jcr->JobId); + Dmsg0(dbglvl, "can_reserve_drive!=1\n"); goto bail_out; } dev->reserved_device++; - Dmsg4(dbglvl, "JobId=%u Inc reserve=%d dev=%s %p\n", (int)jcr->JobId, dev->reserved_device, + Dmsg3(dbglvl, "Inc reserve=%d dev=%s %p\n", dev->reserved_device, dev->print_name(), dev); dcr->reserved_device = true; ok = true; @@ -1066,6 +1349,51 @@ bail_out: return ok; } +static int is_pool_ok(DCR *dcr) +{ + DEVICE *dev = dcr->dev; + JCR *jcr = dcr->jcr; + + /* Now check if we want the same Pool and pool type */ + if (strcmp(dev->pool_name, dcr->pool_name) == 0 && + strcmp(dev->pool_type, dcr->pool_type) == 0) { + /* OK, compatible device */ + Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name()); + return 1; + } else { + /* Drive Pool not suitable for us */ + Mmsg(jcr->errmsg, _( +"3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"), + (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name, + dev->reserved_device, dev->print_name()); + queue_reserve_message(jcr); + Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n", + dev->pool_name, dcr->pool_name); + } + return 0; +} + +static bool is_max_jobs_ok(DCR *dcr) +{ + DEVICE *dev = dcr->dev; + JCR *jcr = dcr->jcr; + + Dmsg4(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Vol=%s\n", + dcr->VolCatInfo.VolCatMaxJobs, + dcr->VolCatInfo.VolCatJobs, dev->reserved_device, + dcr->VolumeName); + if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <= + (dcr->VolCatInfo.VolCatJobs + dev->reserved_device)) { + /* Max Job Vols depassed or already reserved */ + Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"), + (uint32_t)jcr->JobId, dev->print_name()); + queue_reserve_message(jcr); + Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg); + return false; /* wait */ + } + return true; +} + /* * Returns: 1 if drive can be reserved * 0 if we should wait @@ -1076,11 +1404,15 @@ static int can_reserve_drive(DCR *dcr, RCTX &rctx) DEVICE *dev = dcr->dev; JCR *jcr = dcr->jcr; - Dmsg6(dbglvl, "JobId=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", - (int)jcr->JobId, + Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device, rctx.autochanger_only, rctx.any_drive); + /* Check for max jobs on this Volume */ + if (!is_max_jobs_ok(dcr)) { + return 0; + } + /* setting any_drive overrides PreferMountedVols flag */ if (!rctx.any_drive) { /* @@ -1090,8 +1422,8 @@ static int can_reserve_drive(DCR *dcr, RCTX &rctx) * helps spread the load to the least used drives. */ if (rctx.try_low_use_drive && dev == rctx.low_use_drive) { - Dmsg3(dbglvl, "OK dev=%s == low_drive=%s. JobId=%u\n", - dev->print_name(), rctx.low_use_drive->print_name(), jcr->JobId); + Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n", + dev->print_name(), rctx.low_use_drive->print_name()); return 1; } /* If he wants a free drive, but this one is busy, no go */ @@ -1100,13 +1432,12 @@ static int can_reserve_drive(DCR *dcr, RCTX &rctx) if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) { rctx.num_writers = dev->num_writers + dev->reserved_device; rctx.low_use_drive = dev; - Dmsg3(dbglvl, "JobId=%u set low use drive=%s num_writers=%d\n", - (int)jcr->JobId, dev->print_name(), rctx.num_writers); + Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n", + dev->print_name(), rctx.num_writers); } else { - Dmsg2(dbglvl, "JobId=%u not low use num_writers=%d\n", - (int)jcr->JobId, dev->num_writers+dev->reserved_device); + Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->reserved_device); } - Dmsg1(dbglvl, "failed: !prefMnt && busy. JobId=%u\n", jcr->JobId); + Dmsg0(dbglvl, "failed: !prefMnt && busy.\n"); Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"), jcr->JobId, dev->print_name()); queue_reserve_message(jcr); @@ -1114,12 +1445,11 @@ static int can_reserve_drive(DCR *dcr, RCTX &rctx) } /* Check for prefer mounted volumes */ -// if (rctx.PreferMountedVols && !dev->VolHdr.VolumeName[0] && dev->is_tape()) { if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) { Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"), jcr->JobId, dev->print_name()); queue_reserve_message(jcr); - Dmsg1(dbglvl, "failed: want mounted -- no vol JobId=%u\n", (uint32_t)jcr->JobId); + Dmsg0(dbglvl, "failed: want mounted -- no vol\n"); return 0; /* No volume mounted */ } @@ -1129,12 +1459,11 @@ static int can_reserve_drive(DCR *dcr, RCTX &rctx) */ if (rctx.exact_match && rctx.have_volume) { bool ok; - Dmsg6(dbglvl, "JobId=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", - (int)jcr->JobId, + Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n", rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device, rctx.autochanger_only, rctx.any_drive); - Dmsg5(dbglvl, "JobId=%u have_vol=%d have=%s resvol=%s want=%s\n", - (int)jcr->JobId, rctx.have_volume, dev->VolHdr.VolumeName, + Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n", + rctx.have_volume, dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName); ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 || (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0); @@ -1143,9 +1472,8 @@ static int can_reserve_drive(DCR *dcr, RCTX &rctx) jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName, dev->print_name()); queue_reserve_message(jcr); - Dmsg4(dbglvl, "JobId=%u failed: dev have=%s resvol=%s want=%s\n", - (int)jcr->JobId, dev->VolHdr.VolumeName, - dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName); + Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n", + dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName); return 0; } if (is_volume_in_use(dcr)) { @@ -1158,8 +1486,7 @@ static int can_reserve_drive(DCR *dcr, RCTX &rctx) if (rctx.autochanger_only && !dev->is_busy() && dev->VolHdr.VolumeName[0] == 0) { /* Device is available but not yet reserved, reserve it for us */ - Dmsg2(dbglvl, "OK Res Unused autochanger %s JobId=%u.\n", - dev->print_name(), jcr->JobId); + Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name()); bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name)); bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type)); return 1; /* reserve drive */ @@ -1171,42 +1498,18 @@ static int can_reserve_drive(DCR *dcr, RCTX &rctx) if (dev->num_writers == 0) { /* Now check if there are any reservations on the drive */ if (dev->reserved_device) { - /* Now check if we want the same Pool and pool type */ - if (strcmp(dev->pool_name, dcr->pool_name) == 0 && - strcmp(dev->pool_type, dcr->pool_type) == 0) { - /* OK, compatible device */ - Dmsg2(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches JobId=%u\n", - dev->print_name(), jcr->JobId); - return 1; - } else { - /* Drive Pool not suitable for us */ - Mmsg(jcr->errmsg, _( -"3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"), - jcr->JobId, dcr->pool_name, dev->pool_name, - dev->reserved_device, dev->print_name()); - queue_reserve_message(jcr); - Dmsg3(dbglvl, "JobId=%u failed: busy num_writers=0, reserved, pool=%s wanted=%s\n", - (int)jcr->JobId, dev->pool_name, dcr->pool_name); - return 0; /* wait */ - } + return is_pool_ok(dcr); } else if (dev->can_append()) { - /* Device in append mode, check if changing pool */ - if (strcmp(dev->pool_name, dcr->pool_name) == 0 && - strcmp(dev->pool_type, dcr->pool_type) == 0) { - Dmsg2(dbglvl, "OK dev: %s num_writers=0, can_append, pool matches. JobId=%u\n", - dev->print_name(), jcr->JobId); - /* OK, compatible device */ - return 1; + if (is_pool_ok(dcr)) { + return 1; } else { /* Changing pool, unload old tape if any in drive */ - Dmsg1(dbglvl, "JobId=%u OK dev: num_writers=0, not reserved, pool change, unload changer\n", - (int)jcr->JobId); + Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n"); unload_autochanger(dcr, 0); } } /* Device is available but not yet reserved, reserve it for us */ - Dmsg2(dbglvl, "OK Dev avail reserved %s JobId=%u\n", dev->print_name(), - jcr->JobId); + Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name()); bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name)); bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type)); return 1; /* reserve drive */ @@ -1217,22 +1520,7 @@ static int can_reserve_drive(DCR *dcr, RCTX &rctx) * available if pool is the same). */ if (dev->can_append() || dev->num_writers > 0) { - /* Yes, now check if we want the same Pool and pool type */ - if (strcmp(dev->pool_name, dcr->pool_name) == 0 && - strcmp(dev->pool_type, dcr->pool_type) == 0) { - Dmsg2(dbglvl, "OK dev: %s num_writers>=0, can_append, pool matches. JobId=%u\n", - dev->print_name(), jcr->JobId); - /* OK, compatible device */ - return 1; - } else { - /* Drive Pool not suitable for us */ - Mmsg(jcr->errmsg, _("3609 JobId=%u wants Pool=\"%s\" but has Pool=\"%s\" on drive %s.\n"), - jcr->JobId, dcr->pool_name, dev->pool_name, dev->print_name()); - queue_reserve_message(jcr); - Dmsg3(dbglvl, "JobId=%u failed: busy num_writers>0, can_append, pool=%s wanted=%s\n", - (int)jcr->JobId, dev->pool_name, dcr->pool_name); - return 0; /* wait */ - } + return is_pool_ok(dcr); } else { Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId); Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"), @@ -1244,21 +1532,27 @@ static int can_reserve_drive(DCR *dcr, RCTX &rctx) Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"), jcr->JobId, dev->print_name()); queue_reserve_message(jcr); - Dmsg2(dbglvl, "failed: No reserve %s JobId=%u\n", dev->print_name(), jcr->JobId); + Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name()); return 0; } + + + /* - * search_lock is already set on entering this routine + * Queue a reservation error or failure message for this jcr */ static void queue_reserve_message(JCR *jcr) { int i; - alist *msgs = jcr->reserve_msgs; + alist *msgs; char *msg; + jcr->lock(); + + msgs = jcr->reserve_msgs; if (!msgs) { - return; + goto bail_out; } /* * Look for duplicate message. If found, do @@ -1267,15 +1561,18 @@ static void queue_reserve_message(JCR *jcr) for (i=msgs->size()-1; i >= 0; i--) { msg = (char *)msgs->get(i); if (!msg) { - return; + goto bail_out; } /* Comparison based on 4 digit message number */ if (strncmp(msg, jcr->errmsg, 4) == 0) { - return; + goto bail_out; } } /* Message unique, so insert it */ jcr->reserve_msgs->push(bstrdup(jcr->errmsg)); + +bail_out: + jcr->unlock(); } /* @@ -1287,11 +1584,10 @@ void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, alist *msgs; char *msg; - lock_reservations(); + jcr->lock(); msgs = jcr->reserve_msgs; if (!msgs || msgs->size() == 0) { - unlock_reservations(); - return; + goto bail_out; } for (i=msgs->size()-1; i >= 0; i--) { msg = (char *)msgs->get(i); @@ -1302,5 +1598,44 @@ void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, break; } } - unlock_reservations(); + +bail_out: + jcr->unlock(); +} + +/* + * Pop and release any reservations messages + */ +static void pop_reserve_messages(JCR *jcr) +{ + alist *msgs; + char *msg; + + jcr->lock(); + msgs = jcr->reserve_msgs; + if (!msgs) { + goto bail_out; + } + while ((msg = (char *)msgs->pop())) { + free(msg); + } +bail_out: + jcr->unlock(); +} + +/* + * Also called from acquire.c + */ +void release_reserve_messages(JCR *jcr) +{ + pop_reserve_messages(jcr); + jcr->lock(); + if (!jcr->reserve_msgs) { + goto bail_out; + } + delete jcr->reserve_msgs; + jcr->reserve_msgs = NULL; + +bail_out: + jcr->unlock(); }