git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/reserve.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
   5
   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
  11    in the file LICENSE.
  12
  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.
  17
  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
  21    02110-1301, USA.
  22
  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.
  27 */
  28 /*
  29  *   Drive reservation functions for Storage Daemon
  30  *
  31  *   Kern Sibbald, MM
  32  *
  33  *   Split from job.c and acquire.c June 2005
  34  *
  35  *   Version $Id$
  36  *
  37  */
  38
  39 #include "bacula.h"
  40 #include "stored.h"
  41
  42 #define jid() ((int)get_jobid_from_tid())
  43
  44 const int dbglvl =  50;
  45
  46 static dlist *vol_list = NULL;
  47 static brwlock_t reservation_lock;
  48 static brwlock_t vol_list_lock;
  49
  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
  58 /* Requests from the Director daemon */
  59 static char use_storage[]  = "use storage=%127s media_type=%127s "
  60    "pool_name=%127s pool_type=%127s append=%d copy=%d stripe=%d\n";
  61 static char use_device[]  = "use device=%127s\n";
  62
  63 /* Responses sent to Director daemon */
  64 static char OK_device[] = "3000 OK use device device=%s\n";
  65 static char NO_device[] = "3924 Device \"%s\" not in SD Device resources.\n";
  66 static char BAD_use[]   = "3913 Bad use command: %s\n";
  67
  68 bool use_cmd(JCR *jcr)
  69 {
  70    /*
  71     * Get the device, media, and pool information
  72     */
  73    if (!use_storage_cmd(jcr)) {
  74       set_jcr_job_status(jcr, JS_ErrorTerminated);
  75       memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
  76       return false;
  77    }
  78    return true;
  79 }
  80
  81 static int my_compare(void *item1, void *item2)
  82 {
  83    return strcmp(((VOLRES *)item1)->vol_name, ((VOLRES *)item2)->vol_name);
  84 }
  85
  86
  87 void init_reservations_lock()
  88 {
  89    int errstat;
  90    if ((errstat=rwl_init(&reservation_lock)) != 0) {
  91       berrno be;
  92       Emsg1(M_ABORT, 0, _("Unable to initialize reservation lock. ERR=%s\n"),
  93             be.bstrerror(errstat));
  94    }
  95
  96    if ((errstat=rwl_init(&vol_list_lock)) != 0) {
  97       berrno be;
  98       Emsg1(M_ABORT, 0, _("Unable to initialize volume list lock. ERR=%s\n"),
  99             be.bstrerror(errstat));
 100    }
 101 }
 102
 103 void term_reservations_lock()
 104 {
 105    rwl_destroy(&reservation_lock);
 106    rwl_destroy(&vol_list_lock);
 107 }
 108
 109 int reservations_lock_count = 0;
 110
 111 /* This applies to a drive and to Volumes */
 112 void _lock_reservations()
 113 {
 114    int errstat;
 115    reservations_lock_count++;
 116    if ((errstat=rwl_writelock(&reservation_lock)) != 0) {
 117       berrno be;
 118       Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
 119            errstat, be.bstrerror(errstat));
 120    }
 121 }
 122
 123 void _unlock_reservations()
 124 {
 125    int errstat;
 126    reservations_lock_count--;
 127    if ((errstat=rwl_writeunlock(&reservation_lock)) != 0) {
 128       berrno be;
 129       Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
 130            errstat, be.bstrerror(errstat));
 131    }
 132 }
 133
 134 int vol_list_lock_count = 0;
 135
 136 void _lock_volumes()
 137 {
 138    int errstat;
 139    vol_list_lock_count++;
 140    if ((errstat=rwl_writelock(&vol_list_lock)) != 0) {
 141       berrno be;
 142       Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
 143            errstat, be.bstrerror(errstat));
 144    }
 145 }
 146
 147 void _unlock_volumes()
 148 {
 149    int errstat;
 150    vol_list_lock_count--;
 151    if ((errstat=rwl_writeunlock(&vol_list_lock)) != 0) {
 152       berrno be;
 153       Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
 154            errstat, be.bstrerror(errstat));
 155    }
 156 }
 157
 158
 159 /*
 160  * List Volumes -- this should be moved to status.c
 161  */
 162 enum {
 163    debug_lock = true,
 164    debug_nolock = false
 165 };
 166
 167 static void debug_list_volumes(const char *imsg)
 168 {
 169    VOLRES *vol;
 170    POOL_MEM msg(PM_MESSAGE);
 171
 172    lock_volumes();
 173    foreach_dlist(vol, vol_list) {
 174       if (vol->dev) {
 175          Mmsg(msg, "List from %s: %s at %p on device %s\n", imsg,
 176               vol->vol_name, vol->vol_name, vol->dev->print_name());
 177       } else {
 178          Mmsg(msg, "List from %s: %s at %p no dev\n", imsg, vol->vol_name, vol->vol_name);
 179       }
 180       Dmsg2(dbglvl, "jid=%u %s", jid(), msg.c_str());
 181    }
 182
 183 #ifdef xxx
 184    DEVICE *dev = NULL;
 185    foreach_dlist(vol, vol_list) {
 186       if (vol->dev == dev) {
 187          Dmsg0(000, "Two Volumes on same device.\n");
 188          ASSERT(0);
 189          dev = vol->dev;
 190       }
 191    }
 192 #endif
 193
 194 // Dmsg2(dbglvl, "List from %s: %d volumes\n", imsg, count);
 195    unlock_volumes();
 196 }
 197
 198
 199 /*
 200  * List Volumes -- this should be moved to status.c
 201  */
 202 void list_volumes(void sendit(const char *msg, int len, void *sarg), void *arg)
 203 {
 204    VOLRES *vol;
 205    POOL_MEM msg(PM_MESSAGE);
 206    int len;
 207
 208    lock_volumes();
 209    foreach_dlist(vol, vol_list) {
 210       DEVICE *dev = vol->dev;
 211       if (dev) {
 212          len = Mmsg(msg, "%s on device %s\n", vol->vol_name, dev->print_name());
 213          sendit(msg.c_str(), len, arg);
 214          len = Mmsg(msg, "    Reader=%d writers=%d reserved=%d\n", dev->can_read()?1:0,
 215             dev->num_writers, dev->reserved_device);
 216          sendit(msg.c_str(), len, arg);
 217       } else {
 218          len = Mmsg(msg, "%s no dev\n", vol->vol_name);
 219          sendit(msg.c_str(), len, arg);
 220       }
 221    }
 222    unlock_volumes();
 223 }
 224
 225 /*
 226  * Create a Volume item to put in the Volume list
 227  *   Ensure that the device points to it.
 228  */
 229 static VOLRES *new_vol_item(DCR *dcr, const char *VolumeName)
 230 {
 231    VOLRES *vol;
 232    vol = (VOLRES *)malloc(sizeof(VOLRES));
 233    memset(vol, 0, sizeof(VOLRES));
 234    vol->vol_name = bstrdup(VolumeName);
 235    vol->dev = dcr->dev;
 236    Dmsg4(dbglvl, "jid=%u new Vol=%s at %p dev=%s\n", (int)dcr->jcr->JobId,
 237          VolumeName, vol->vol_name, vol->dev->print_name());
 238    return vol;
 239 }
 240
 241 static void free_vol_item(VOLRES *vol)
 242 {
 243    free(vol->vol_name);
 244    if (vol->dev) {
 245       vol->dev->vol = NULL;
 246    }
 247    free(vol);
 248 }
 249
 250
 251 /*
 252  * Put a new Volume entry in the Volume list. This
 253  *  effectively reserves the volume so that it will
 254  *  not be mounted again.
 255  *
 256  * If the device has any current volume associated with it,
 257  *  and it is a different Volume, and the device is not busy,
 258  *  we release the old Volume item and insert the new one.
 259  *
 260  * It is assumed that the device is free and locked so that
 261  *  we can change the device structure.
 262  *
 263  * Some details of the Volume list handling:
 264  *
 265  *  1. The Volume list entry must be attached to the drive (rather than
 266  *       attached to a job as it currently is. I.e. the drive that "owns"
 267  *       the volume (reserved, in use, mounted)
 268  *       must point to the volume (still to be maintained in a list).
 269  *
 270  *  2. The Volume is entered in the list when a drive is reserved.
 271  *
 272  *  3. When a drive is in use, the device code must appropriately update the
 273  *      volume name as it changes (currently the list is static -- an entry is
 274  *      removed when the Volume is no longer reserved, in use or mounted).
 275  *      The new code must keep the same list entry as long as the drive
 276  *       has any volume associated with it but the volume name in the list
 277  *       must be updated when the drive has a different volume mounted.
 278  *
 279  *  4. A job that has reserved a volume, can un-reserve the volume, and if the
 280  *      volume is not mounted, and not reserved, and not in use, it will be
 281  *      removed from the list.
 282  *
 283  *  5. If a job wants to reserve a drive with a different Volume from the one on
 284  *      the drive, it can re-use the drive for the new Volume.
 285  *
 286  *  6. If a job wants a Volume that is in a different drive, it can either use the
 287  *      other drive or take the volume, only if the other drive is not in use or
 288  *      not reserved.
 289  *
 290  *  One nice aspect of this is that the reserve use count and the writer use count
 291  *  already exist and are correctly programmed and will need no changes -- use
 292  *  counts are always very tricky.
 293  *
 294  *  The old code had a concept of "reserving" a Volume, but it needs to be changed
 295  *  to reserving and using a drive.  A volume is must be attached to (owned by) a
 296  *  drive and can move from drive to drive or be unused given certain specific
 297  *  conditions of the drive.  The key is that the drive must "own" the Volume.
 298  *  The old code has the job (dcr) owning the volume (more or less).  The job is
 299  *  to change the insertion and removal of the volumes from the list to be based
 300  *  on the drive rather than the job.
 301  *
 302  *  Return: VOLRES entry on success
 303  *          NULL volume busy on another drive
 304  */
 305 VOLRES *reserve_volume(DCR *dcr, const char *VolumeName)
 306 {
 307    VOLRES *vol, *nvol;
 308    DEVICE *dev = dcr->dev;
 309
 310    ASSERT(dev != NULL);
 311
 312    Dmsg2(dbglvl, "jid=%u reserve_volume %s\n", jid(), VolumeName);
 313    /*
 314     * We lock the reservations system here to ensure
 315     *  when adding a new volume that no newly scheduled
 316     *  job can reserve it.
 317     */
 318    lock_volumes();
 319    debug_list_volumes("begin reserve_volume");
 320    /*
 321     * First, remove any old volume attached to this device as it
 322     *  is no longer used.
 323     */
 324    if (dev->vol) {
 325       vol = dev->vol;
 326       /*
 327        * Make sure we don't remove the current volume we are inserting
 328        *  because it was probably inserted by another job.
 329        */
 330       if (strcmp(vol->vol_name, VolumeName) == 0) {
 331          goto get_out;                  /* Volume already on this device */
 332       } else {
 333          Dmsg3(dbglvl, "jid=%u reserve_vol free vol=%s at %p\n",
 334                (int)dcr->jcr->JobId, vol->vol_name, vol->vol_name);
 335          debug_list_volumes("reserve_vol free");
 336          vol_list->remove(vol);
 337          free_vol_item(vol);
 338       }
 339    }
 340
 341    /* Create a new Volume entry */
 342    nvol = new_vol_item(dcr, VolumeName);
 343
 344    /*
 345     * Now try to insert the new Volume
 346     */
 347    vol = (VOLRES *)vol_list->binary_insert(nvol, my_compare);
 348    if (vol != nvol) {
 349       Dmsg3(dbglvl, "jid=%u Found vol=%s dev-same=%d\n", jid(), vol->vol_name, dev==vol->dev);
 350       /*
 351        * At this point, a Volume with this name already is in the list,
 352        *   so we simply release our new Volume entry. Note, this should
 353        *   only happen if we are moving the volume from one drive to another.
 354        */
 355       Dmsg3(dbglvl, "jid=%u reserve_vol free-tmp vol=%s at %p\n",
 356             (int)dcr->jcr->JobId, vol->vol_name, vol->vol_name);
 357       /*
 358        * Clear dev pointer so that free_vol_item() doesn't
 359        *  take away our volume.
 360        */
 361       nvol->dev = NULL;                   /* don't zap dev entry */
 362       free_vol_item(nvol);
 363
 364       /* Check if we are trying to use the Volume on a different drive */
 365       if (dev != vol->dev) {
 366          /* Caller wants to switch Volume to another device */
 367          if (!vol->dev->is_busy()) {
 368             /* OK to move it -- I'm not sure this will work */
 369             Dmsg4(dbglvl, "==== jid=%u Swap vol=%s from dev=%s to %s\n", jid(), VolumeName,
 370                vol->dev->print_name(), dev->print_name());
 371             vol->dev->vol = NULL;         /* take vol from old drive */
 372             vol->dev->VolHdr.VolumeName[0] = 0;
 373             vol->dev = dev;               /* point vol at new drive */
 374             dev->vol = vol;               /* point dev at vol */
 375             dev->VolHdr.VolumeName[0] = 0;
 376          } else {
 377             Dmsg4(dbglvl, "jid=%u Volume busy could not swap vol=%s from dev=%s to %s\n",
 378                jid(), VolumeName, vol->dev->print_name(), dev->print_name());
 379             vol = NULL;                /* device busy */
 380          }
 381       }
 382    }
 383    dev->vol = vol;
 384
 385 get_out:
 386    debug_list_volumes("end new volume");
 387    unlock_volumes();
 388    return vol;
 389 }
 390
 391 /*
 392  * Search for a Volume name in the Volume list.
 393  *
 394  *  Returns: VOLRES entry on success
 395  *           NULL if the Volume is not in the list
 396  */
 397 VOLRES *find_volume(DCR *dcr)
 398 {
 399    VOLRES vol, *fvol;
 400    /* Do not lock reservations here */
 401    lock_volumes();
 402    vol.vol_name = bstrdup(dcr->VolumeName);
 403    fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
 404    free(vol.vol_name);
 405    Dmsg3(dbglvl, "jid=%u find_vol=%s found=%d\n", jid(), dcr->VolumeName, fvol!=NULL);
 406    debug_list_volumes("find_volume");
 407    unlock_volumes();
 408    return fvol;
 409 }
 410
 411 /*
 412  * Remove any reservation from a drive and tell the system
 413  *  that the volume is unused at least by us.
 414  */
 415 void unreserve_device(DCR *dcr)
 416 {
 417    DEVICE *dev = dcr->dev;
 418    dev->dlock();
 419    if (dcr->reserved_device) {
 420       dcr->reserved_device = false;
 421       dev->reserved_device--;
 422       Dmsg3(dbglvl, "jid=%u Dec reserve=%d dev=%s\n", jid(), dev->reserved_device, dev->print_name());
 423       dcr->reserved_device = false;
 424       /* If we set read mode in reserving, remove it */
 425       if (dev->can_read()) {
 426          dev->clear_read();
 427       }
 428       if (dev->num_writers < 0) {
 429          Jmsg1(dcr->jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
 430          dev->num_writers = 0;
 431       }
 432    }
 433
 434    volume_unused(dcr);
 435    dev->dunlock();
 436 }
 437
 438 /*
 439  * Free a Volume from the Volume list if it is no longer used
 440  *
 441  *  Returns: true if the Volume found and removed from the list
 442  *           false if the Volume is not in the list or is in use
 443  */
 444 bool volume_unused(DCR *dcr)
 445 {
 446    DEVICE *dev = dcr->dev;
 447
 448    if (dev->vol == NULL) {
 449       Dmsg2(dbglvl, "jid=%u vol_unused: no vol on %s\n", (int)dcr->jcr->JobId, dev->print_name());
 450       debug_list_volumes("null vol cannot unreserve_volume");
 451       return false;
 452    }
 453
 454    if (dev->is_busy()) {
 455       Dmsg2(dbglvl, "jid=%u vol_unused: no vol on %s\n", (int)dcr->jcr->JobId, dev->print_name());
 456       debug_list_volumes("dev busy cannot unreserve_volume");
 457       return false;
 458    }
 459
 460    /*
 461     * If this is a tape, we do not free the volume, rather we wait
 462     *  until the autoloader unloads it, or until another tape is
 463     *  explicitly read in this drive. This allows the SD to remember
 464     *  where the tapes are or last were.
 465     */
 466    if (dev->is_tape() || dev->is_autochanger()) {
 467       return true;
 468    } else {
 469       return free_volume(dev);
 470    }
 471 }
 472
 473 /*
 474  * Unconditionally release the volume
 475  */
 476 bool free_volume(DEVICE *dev)
 477 {
 478    VOLRES *vol;
 479
 480    if (dev->vol == NULL) {
 481       Dmsg2(dbglvl, "jid=%u No vol on dev %s\n", jid(), dev->print_name());
 482       return false;
 483    }
 484    lock_volumes();
 485    vol = dev->vol;
 486    dev->vol = NULL;
 487    vol_list->remove(vol);
 488    Dmsg3(dbglvl, "jid=%u free_volume %s dev=%s\n", jid(), vol->vol_name, dev->print_name());
 489    free_vol_item(vol);
 490    debug_list_volumes("free_volume");
 491    unlock_volumes();
 492    return vol != NULL;
 493 }
 494
 495
 496 /* Create the Volume list */
 497 void create_volume_list()
 498 {
 499    VOLRES *vol = NULL;
 500    if (vol_list == NULL) {
 501       vol_list = New(dlist(vol, &vol->link));
 502    }
 503 }
 504
 505 /* Release all Volumes from the list */
 506 void free_volume_list()
 507 {
 508    VOLRES *vol;
 509    if (!vol_list) {
 510       return;
 511    }
 512    lock_volumes();
 513    foreach_dlist(vol, vol_list) {
 514       if (vol->dev) {
 515          Dmsg3(dbglvl, "jid=%u free vol_list Volume=%s dev=%s\n", jid(),
 516                vol->vol_name, vol->dev->print_name());
 517       } else {
 518          Dmsg3(dbglvl, "jid=%u free vol_list Volume=%s dev=%p\n", jid(),
 519                vol->vol_name, vol->dev);
 520       }
 521       free(vol->vol_name);
 522       vol->vol_name = NULL;
 523    }
 524    delete vol_list;
 525    vol_list = NULL;
 526    unlock_volumes();
 527 }
 528
 529 bool is_volume_in_use(DCR *dcr)
 530 {
 531    VOLRES *vol = find_volume(dcr);
 532    if (!vol) {
 533       Dmsg2(dbglvl, "jid=%u Vol=%s not in use.\n", jid(), dcr->VolumeName);
 534       return false;                   /* vol not in list */
 535    }
 536    ASSERT(vol->dev != NULL);
 537
 538    if (dcr->dev == vol->dev) {        /* same device OK */
 539       Dmsg2(dbglvl, "jid=%u Vol=%s on same dev.\n", jid(), dcr->VolumeName);
 540       return false;
 541    } else {
 542       Dmsg4(dbglvl, "jid=%u Vol=%s on %s we have %s\n", jid(), dcr->VolumeName,
 543             vol->dev->print_name(), dcr->dev->print_name());
 544    }
 545    if (!vol->dev->is_busy()) {
 546       Dmsg3(dbglvl, "jid=%u Vol=%s dev=%s not busy.\n", jid(), dcr->VolumeName, vol->dev->print_name());
 547       return false;
 548    } else {
 549       Dmsg3(dbglvl, "jid=%u Vol=%s dev=%s busy.\n", jid(), dcr->VolumeName, vol->dev->print_name());
 550    }
 551    Dmsg3(dbglvl, "jid=%u Vol=%s in use by %s.\n", jid(), dcr->VolumeName, vol->dev->print_name());
 552    return true;
 553 }
 554
 555
 556 /*
 557  * We get the following type of information:
 558  *
 559  * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
 560  *  use device=zzz
 561  *  use device=aaa
 562  *  use device=bbb
 563  * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
 564  *  use device=bbb
 565  *
 566  */
 567 static bool use_storage_cmd(JCR *jcr)
 568 {
 569    POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
 570    BSOCK *dir = jcr->dir_bsock;
 571    int append;
 572    bool ok;
 573    int Copy, Stripe;
 574    DIRSTORE *store;
 575    RCTX rctx;
 576    char *msg;
 577    alist *msgs;
 578    alist *dirstore;
 579
 580    memset(&rctx, 0, sizeof(RCTX));
 581    rctx.jcr = jcr;
 582    /*
 583     * If there are multiple devices, the director sends us
 584     *   use_device for each device that it wants to use.
 585     */
 586    dirstore = New(alist(10, not_owned_by_alist));
 587    msgs = jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
 588    do {
 589       Dmsg2(dbglvl, "jid=%u <dird: %s", jid(), dir->msg);
 590       ok = sscanf(dir->msg, use_storage, store_name.c_str(),
 591                   media_type.c_str(), pool_name.c_str(),
 592                   pool_type.c_str(), &append, &Copy, &Stripe) == 7;
 593       if (!ok) {
 594          break;
 595       }
 596       if (append) {
 597          jcr->write_store = dirstore;
 598       } else {
 599          jcr->read_store = dirstore;
 600       }
 601       rctx.append = append;
 602       unbash_spaces(store_name);
 603       unbash_spaces(media_type);
 604       unbash_spaces(pool_name);
 605       unbash_spaces(pool_type);
 606       store = new DIRSTORE;
 607       dirstore->append(store);
 608       memset(store, 0, sizeof(DIRSTORE));
 609       store->device = New(alist(10));
 610       bstrncpy(store->name, store_name, sizeof(store->name));
 611       bstrncpy(store->media_type, media_type, sizeof(store->media_type));
 612       bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
 613       bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
 614       store->append = append;
 615
 616       /* Now get all devices */
 617       while (dir->recv() >= 0) {
 618          Dmsg2(dbglvl, "jid=%u <dird device: %s", jid(), dir->msg);
 619          ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
 620          if (!ok) {
 621             break;
 622          }
 623          unbash_spaces(dev_name);
 624          store->device->append(bstrdup(dev_name.c_str()));
 625       }
 626    }  while (ok && dir->recv() >= 0);
 627
 628    /* Developer debug code */
 629    char *device_name;
 630    if (debug_level >= dbglvl) {
 631       foreach_alist(store, dirstore) {
 632          Dmsg6(dbglvl, "jid=%u Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
 633             (int)rctx.jcr->JobId,
 634             store->name, store->media_type, store->pool_name,
 635             store->pool_type, store->append);
 636          foreach_alist(device_name, store->device) {
 637             Dmsg2(dbglvl, "jid=%u     Device=%s\n", jid(), device_name);
 638          }
 639       }
 640    }
 641
 642    init_jcr_device_wait_timers(jcr);
 643    jcr->dcr = new_dcr(jcr, NULL, NULL);         /* get a dcr */
 644    if (!jcr->dcr) {
 645       BSOCK *dir = jcr->dir_bsock;
 646       dir->fsend(_("3939 Could not get dcr\n"));
 647       Dmsg1(dbglvl, ">dird: %s", dir->msg);
 648       ok = false;
 649    }
 650    /*
 651     * At this point, we have a list of all the Director's Storage
 652     *  resources indicated for this Job, which include Pool, PoolType,
 653     *  storage name, and Media type.
 654     * Then for each of the Storage resources, we have a list of
 655     *  device names that were given.
 656     *
 657     * Wiffle through them and find one that can do the backup.
 658     */
 659    if (ok) {
 660       int wait_for_device_retries = 0;
 661       int repeat = 0;
 662       bool fail = false;
 663       rctx.notify_dir = true;
 664
 665       lock_reservations();
 666       for ( ; !fail && !job_canceled(jcr); ) {
 667          while ((msg = (char *)msgs->pop())) {
 668             free(msg);
 669          }
 670          rctx.suitable_device = false;
 671          rctx.have_volume = false;
 672          rctx.VolumeName[0] = 0;
 673          rctx.any_drive = false;
 674          if (!jcr->PreferMountedVols) {
 675             /*
 676              * Here we try to find a drive that is not used.
 677              * This will maximize the use of available drives.
 678              *
 679              */
 680             rctx.num_writers = 20000000;   /* start with impossible number */
 681             rctx.low_use_drive = NULL;
 682             rctx.PreferMountedVols = false;
 683             rctx.exact_match = false;
 684             rctx.autochanger_only = true;
 685             Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
 686                (int)rctx.jcr->JobId,
 687                rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
 688                rctx.autochanger_only, rctx.any_drive);
 689             if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 690                break;
 691             }
 692             /* Look through all drives possibly for low_use drive */
 693             if (rctx.low_use_drive) {
 694                rctx.try_low_use_drive = true;
 695                if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 696                   break;
 697                }
 698                rctx.try_low_use_drive = false;
 699             }
 700             rctx.autochanger_only = false;
 701             Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
 702                (int)rctx.jcr->JobId,
 703                rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
 704                rctx.autochanger_only, rctx.any_drive);
 705             if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 706                break;
 707             }
 708          }
 709          /*
 710           * Now we look for a drive that may or may not be in
 711           *  use.
 712           */
 713          /* Look for an exact Volume match all drives */
 714          rctx.PreferMountedVols = true;
 715          rctx.exact_match = true;
 716          rctx.autochanger_only = false;
 717          Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
 718             (int)rctx.jcr->JobId,
 719             rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
 720             rctx.autochanger_only, rctx.any_drive);
 721          if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 722             break;
 723          }
 724          /* Look for any mounted drive */
 725          rctx.exact_match = false;
 726          Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
 727             (int)rctx.jcr->JobId,
 728             rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
 729             rctx.autochanger_only, rctx.any_drive);
 730          if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 731             break;
 732          }
 733          /* Try any drive */
 734          rctx.any_drive = true;
 735          Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
 736             (int)rctx.jcr->JobId,
 737             rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
 738             rctx.autochanger_only, rctx.any_drive);
 739          if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 740             break;
 741          }
 742          /* Keep reservations locked *except* during wait_for_device() */
 743          unlock_reservations();
 744          /*
 745           * The idea of looping on repeat a few times it to ensure
 746           * that if there is some subtle timing problem between two
 747           * jobs, we will simply try again, and most likely succeed.
 748           * This can happen if one job reserves a drive or finishes using
 749           * a drive at the same time a second job wants it.
 750           */
 751          if (repeat++ > 1) {              /* try algorithm 3 times */
 752             bmicrosleep(30, 0);           /* wait a bit */
 753             Dmsg1(dbglvl, "jid=%u repeat reserve algorithm\n", (int)rctx.jcr->JobId);
 754          } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
 755             Dmsg1(dbglvl, "jid=%u Fail. !suitable_device || !wait_for_device\n",
 756                  (int)rctx.jcr->JobId);
 757             fail = true;
 758          }
 759          lock_reservations();
 760          dir->signal(BNET_HEARTBEAT);  /* Inform Dir that we are alive */
 761       }
 762       unlock_reservations();
 763       if (!ok) {
 764          /*
 765           * If we get here, there are no suitable devices available, which
 766           *  means nothing configured.  If a device is suitable but busy
 767           *  with another Volume, we will not come here.
 768           */
 769          unbash_spaces(dir->msg);
 770          pm_strcpy(jcr->errmsg, dir->msg);
 771          Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
 772          Jmsg(jcr, M_FATAL, 0, _("\n"
 773             "     Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
 774               dev_name.c_str(), media_type.c_str());
 775          dir->fsend(NO_device, dev_name.c_str());
 776
 777          Dmsg2(dbglvl, "jid=%u >dird: %s", jid(), dir->msg);
 778       }
 779    } else {
 780       unbash_spaces(dir->msg);
 781       pm_strcpy(jcr->errmsg, dir->msg);
 782       Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
 783       dir->fsend(BAD_use, jcr->errmsg);
 784       Dmsg2(dbglvl, "jid=%u >dird: %s", jid(), dir->msg);
 785    }
 786
 787    release_msgs(jcr);
 788    return ok;
 789 }
 790
 791 void release_msgs(JCR *jcr)
 792 {
 793    alist *msgs = jcr->reserve_msgs;
 794    char *msg;
 795
 796    if (!msgs) {
 797       return;
 798    }
 799    lock_reservations();
 800    while ((msg = (char *)msgs->pop())) {
 801       free(msg);
 802    }
 803    delete msgs;
 804    jcr->reserve_msgs = NULL;
 805    unlock_reservations();
 806 }
 807
 808 /*
 809  * Walk through the autochanger resources and check if
 810  *  the volume is in one of them.
 811  *
 812  * Returns:  true  if volume is in device
 813  *           false otherwise
 814  */
 815 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
 816 {
 817    AUTOCHANGER *changer = vol->dev->device->changer_res;
 818
 819    /* Find resource, and make sure we were able to open it */
 820    if (fnmatch(rctx.device_name, changer->hdr.name, 0) == 0) {
 821       Dmsg2(dbglvl, "jid=%u Found changer device %s\n",
 822                      (int)rctx.jcr->JobId, vol->dev->device->hdr.name);
 823       return true;
 824    }
 825    Dmsg2(dbglvl, "jid=%u Incorrect changer device %s\n",
 826                   (int)rctx.jcr->JobId, changer->hdr.name);
 827    return false;
 828 }
 829
 830 /*
 831  * Search for a device suitable for this job.
 832  */
 833 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
 834 {
 835    bool ok = false;
 836    DIRSTORE *store;
 837    char *device_name;
 838    alist *dirstore;
 839    DCR *dcr = jcr->dcr;
 840
 841    if (rctx.append) {
 842       dirstore = jcr->write_store;
 843    } else {
 844       dirstore = jcr->read_store;
 845    }
 846    Dmsg5(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
 847       (int)rctx.jcr->JobId,
 848       rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
 849       rctx.autochanger_only);
 850
 851    /*
 852     * If the appropriate conditions of this if are met, namely that
 853     *  we are appending and the user wants mounted drive (or we
 854     *  force try a mounted drive because they are all busy), we
 855     *  start by looking at all the Volumes in the volume list.
 856     */
 857    if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
 858       dlist *temp_vol_list, *save_vol_list;
 859       VOLRES *vol = NULL;
 860       lock_volumes();
 861
 862       /*
 863        * Create a temporary copy of the volume list.  We do this,
 864        *   to avoid having the volume list locked during the
 865        *   call to reserve_device(), which would cause a deadlock.
 866        * Note, we may want to add an update counter on the vol_list
 867        *   so that if it is modified while we are traversing the copy
 868        *   we can take note and act accordingly (probably redo the
 869        *   search at least a few times).
 870        */
 871       Dmsg1(dbglvl, "jid=%u duplicate vol list\n", (int)rctx.jcr->JobId);
 872       temp_vol_list = New(dlist(vol, &vol->link));
 873       foreach_dlist(vol, vol_list) {
 874          VOLRES *nvol;
 875          VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
 876          memset(tvol, 0, sizeof(VOLRES));
 877          tvol->vol_name = bstrdup(vol->vol_name);
 878          tvol->dev = vol->dev;
 879          nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
 880          if (tvol != nvol) {
 881             tvol->dev = NULL;                   /* don't zap dev entry */
 882             free_vol_item(tvol);
 883             Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
 884             Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
 885          }
 886       }
 887       unlock_volumes();
 888
 889       /* Look through reserved volumes for one we can use */
 890       Dmsg1(dbglvl, "jid=%u look for vol in vol list\n", (int)rctx.jcr->JobId);
 891       foreach_dlist(vol, temp_vol_list) {
 892          if (!vol->dev) {
 893             Dmsg2(dbglvl, "jid=%u vol=%s no dev\n", (int)rctx.jcr->JobId, vol->vol_name);
 894             continue;
 895          }
 896          /* Check with Director if this Volume is OK */
 897          bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
 898          if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
 899             continue;
 900          }
 901
 902          Dmsg2(dbglvl, "jid=%u vol=%s OK for this job\n", (int)rctx.jcr->JobId, vol->vol_name);
 903          foreach_alist(store, dirstore) {
 904             int stat;
 905             rctx.store = store;
 906             foreach_alist(device_name, store->device) {
 907                /* Found a device, try to use it */
 908                rctx.device_name = device_name;
 909                rctx.device = vol->dev->device;
 910
 911                if (vol->dev->is_autochanger()) {
 912                   Dmsg2(dbglvl, "jid=%u vol=%s is in changer\n", (int)rctx.jcr->JobId,
 913                         vol->vol_name);
 914                   if (!is_vol_in_autochanger(rctx, vol)) {
 915                      continue;
 916                   }
 917                } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
 918                   Dmsg3(dbglvl, "jid=%u device=%s not suitable want %s\n", (int)rctx.jcr->JobId,
 919                         vol->dev->device->hdr.name, device_name);
 920                   continue;
 921                }
 922
 923                bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
 924                rctx.have_volume = true;
 925                /* Try reserving this device and volume */
 926                Dmsg3(dbglvl, "jid=%u try vol=%s on device=%s\n", (int)rctx.jcr->JobId,
 927                      rctx.VolumeName, device_name);
 928                stat = reserve_device(rctx);
 929                if (stat == 1) {             /* found available device */
 930                   Dmsg2(dbglvl, "jid=%u Suitable device found=%s\n", (int)rctx.jcr->JobId,
 931                         device_name);
 932                   ok = true;
 933                   break;
 934                } else if (stat == 0) {      /* device busy */
 935                   Dmsg2(dbglvl, "jid=%u Suitable device=%s, busy: not use\n",
 936                         (int)rctx.jcr->JobId, device_name);
 937                } else {
 938                   /* otherwise error */
 939                   Dmsg1(dbglvl, "jid=%u No suitable device found.\n", (int)rctx.jcr->JobId);
 940                }
 941                rctx.have_volume = false;
 942             }
 943             if (ok) {
 944                break;
 945             }
 946          }
 947          if (ok) {
 948             break;
 949          }
 950       } /* end for loop over reserved volumes */
 951
 952       lock_volumes();
 953       save_vol_list = vol_list;
 954       vol_list = temp_vol_list;
 955       free_volume_list();                  /* release temp_vol_list */
 956       vol_list = save_vol_list;
 957       Dmsg1(dbglvl, "jid=%u deleted temp vol list\n", (int)rctx.jcr->JobId);
 958       unlock_volumes();
 959    }
 960    if (ok) {
 961       Dmsg2(dbglvl, "jid=%u got vol %s from in-use vols list\n", (int)rctx.jcr->JobId,
 962             rctx.VolumeName);
 963       return true;
 964    }
 965
 966    /*
 967     * No reserved volume we can use, so now search for an available device.
 968     *
 969     * For each storage device that the user specified, we
 970     *  search and see if there is a resource for that device.
 971     */
 972    foreach_alist(store, dirstore) {
 973       rctx.store = store;
 974       foreach_alist(device_name, store->device) {
 975          int stat;
 976          rctx.device_name = device_name;
 977          stat = search_res_for_device(rctx);
 978          if (stat == 1) {             /* found available device */
 979             Dmsg2(dbglvl, "jid=%u available device found=%s\n", (int)rctx.jcr->JobId,
 980                   device_name);
 981             ok = true;
 982             break;
 983          } else if (stat == 0) {      /* device busy */
 984             Dmsg2(dbglvl, "jid=%u Suitable device=%s, busy: not use\n",
 985                   (int)rctx.jcr->JobId, device_name);
 986          } else {
 987             /* otherwise error */
 988             Dmsg1(dbglvl, "jid=%u No suitable device found.\n", (int)rctx.jcr->JobId);
 989          }
 990       }
 991       if (ok) {
 992          break;
 993       }
 994    }
 995    return ok;
 996 }
 997
 998 /*
 999  * Search for a particular storage device with particular storage
1000  *  characteristics (MediaType).
1001  */
1002 int search_res_for_device(RCTX &rctx)
1003 {
1004    AUTOCHANGER *changer;
1005    int stat;
1006
1007    Dmsg2(dbglvl, "jid=%u search res for %s\n", (int)rctx.jcr->JobId, rctx.device_name);
1008    /* Look through Autochangers first */
1009    foreach_res(changer, R_AUTOCHANGER) {
1010       Dmsg2(dbglvl, "jid=%u Try match changer res=%s\n", (int)rctx.jcr->JobId, changer->hdr.name);
1011       /* Find resource, and make sure we were able to open it */
1012       if (fnmatch(rctx.device_name, changer->hdr.name, 0) == 0) {
1013          /* Try each device in this AutoChanger */
1014          foreach_alist(rctx.device, changer->device) {
1015             Dmsg2(dbglvl, "jid=%u Try changer device %s\n", (int)rctx.jcr->JobId,
1016                   rctx.device->hdr.name);
1017             stat = reserve_device(rctx);
1018             if (stat != 1) {             /* try another device */
1019                continue;
1020             }
1021             /* Debug code */
1022             if (rctx.store->append == SD_APPEND) {
1023                Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for append.\n",
1024                   (int)rctx.jcr->JobId, rctx.device->hdr.name,
1025                   rctx.jcr->dcr->dev->reserved_device);
1026             } else {
1027                Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for read.\n",
1028                   (int)rctx.jcr->JobId, rctx.device->hdr.name,
1029                   rctx.jcr->read_dcr->dev->reserved_device);
1030             }
1031             return stat;
1032          }
1033       }
1034    }
1035
1036    /* Now if requested look through regular devices */
1037    if (!rctx.autochanger_only) {
1038       foreach_res(rctx.device, R_DEVICE) {
1039          Dmsg2(dbglvl, "jid=%u Try match res=%s\n", (int)rctx.jcr->JobId, rctx.device->hdr.name);
1040          /* Find resource, and make sure we were able to open it */
1041          if (fnmatch(rctx.device_name, rctx.device->hdr.name, 0) == 0) {
1042             stat = reserve_device(rctx);
1043             if (stat != 1) {             /* try another device */
1044                continue;
1045             }
1046             /* Debug code */
1047             if (rctx.store->append == SD_APPEND) {
1048                Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for append.\n",
1049                   (int)rctx.jcr->JobId, rctx.device->hdr.name,
1050                   rctx.jcr->dcr->dev->reserved_device);
1051             } else {
1052                Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for read.\n",
1053                   (int)rctx.jcr->JobId, rctx.device->hdr.name,
1054                   rctx.jcr->read_dcr->dev->reserved_device);
1055             }
1056             return stat;
1057          }
1058       }
1059    }
1060    return -1;                    /* nothing found */
1061 }
1062
1063 /*
1064  *  Try to reserve a specific device.
1065  *
1066  *  Returns: 1 -- OK, have DCR
1067  *           0 -- must wait
1068  *          -1 -- fatal error
1069  */
1070 static int reserve_device(RCTX &rctx)
1071 {
1072    bool ok;
1073    DCR *dcr;
1074    const int name_len = MAX_NAME_LENGTH;
1075
1076    /* Make sure MediaType is OK */
1077    Dmsg3(dbglvl, "jid=%u chk MediaType device=%s request=%s\n",
1078          (int)rctx.jcr->JobId,
1079          rctx.device->media_type, rctx.store->media_type);
1080    if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1081       return -1;
1082    }
1083
1084    /* Make sure device exists -- i.e. we can stat() it */
1085    if (!rctx.device->dev) {
1086       rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1087    }
1088    if (!rctx.device->dev) {
1089       if (rctx.device->changer_res) {
1090         Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1091            "     Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1092              rctx.device->hdr.name, rctx.device_name);
1093       } else {
1094          Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1095             "     Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1096               rctx.device_name);
1097       }
1098       return -1;  /* no use waiting */
1099    }
1100
1101    rctx.suitable_device = true;
1102    Dmsg2(dbglvl, "jid=%u try reserve %s\n", rctx.jcr->JobId, rctx.device->hdr.name);
1103    rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1104    if (!dcr) {
1105       BSOCK *dir = rctx.jcr->dir_bsock;
1106       dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1107       Dmsg1(dbglvl, ">dird: %s", dir->msg);
1108       return -1;
1109    }
1110    bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1111    bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1112    bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1113    bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1114    if (rctx.store->append == SD_APPEND) {
1115       Dmsg3(dbglvl, "jid=%u have_vol=%d vol=%s\n", (int)rctx.jcr->JobId,
1116           rctx.have_volume, rctx.VolumeName);
1117       ok = reserve_device_for_append(dcr, rctx);
1118       if (!ok) {
1119          goto bail_out;
1120       }
1121
1122       rctx.jcr->dcr = dcr;
1123       Dmsg6(dbglvl, "jid=%u Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1124                (int)rctx.jcr->JobId,
1125                dcr->dev->reserved_device,
1126                dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1127       if (!rctx.have_volume) {
1128          dcr->any_volume = true;
1129          if (dir_find_next_appendable_volume(dcr)) {
1130             bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1131             Dmsg2(dbglvl, "jid=%u looking for Volume=%s\n", (int)rctx.jcr->JobId, rctx.VolumeName);
1132             rctx.have_volume = true;
1133          } else {
1134             Dmsg1(dbglvl, "jid=%u No next volume found\n", (int)rctx.jcr->JobId);
1135             rctx.have_volume = false;
1136             rctx.VolumeName[0] = 0;
1137             /*
1138              * If there is at least one volume that is valid and in use,
1139              *   but we get here, check if we are running with prefers
1140              *   non-mounted drives.  In that case, we have selected a
1141              *   non-used drive and our one and only volume is mounted
1142              *   elsewhere, so we bail out and retry using that drive.
1143              */
1144             if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1145                rctx.PreferMountedVols = true;
1146                goto bail_out;
1147             }
1148          }
1149       }
1150    } else {
1151       ok = reserve_device_for_read(dcr);
1152       if (ok) {
1153          rctx.jcr->read_dcr = dcr;
1154          Dmsg6(dbglvl, "jid=%u Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1155                (int)rctx.jcr->JobId,
1156                dcr->dev->reserved_device,
1157                dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1158       }
1159    }
1160    if (!ok) {
1161       goto bail_out;
1162    }
1163    if (rctx.notify_dir) {
1164       POOL_MEM dev_name;
1165       BSOCK *dir = rctx.jcr->dir_bsock;
1166       pm_strcpy(dev_name, rctx.device->hdr.name);
1167       bash_spaces(dev_name);
1168       ok = dir->fsend(OK_device, dev_name.c_str());  /* Return real device name */
1169       Dmsg2(dbglvl, "jid=%u >dird changer: %s", jid(), dir->msg);
1170    } else {
1171       ok = true;
1172    }
1173    return ok ? 1 : -1;
1174
1175 bail_out:
1176    rctx.have_volume = false;
1177 // free_dcr(dcr);
1178    Dmsg1(dbglvl, "jid=%u Not OK.\n", (int)rctx.jcr->JobId);
1179    return 0;
1180 }
1181
1182 /*
1183  * We "reserve" the drive by setting the ST_READ bit. No one else
1184  *  should touch the drive until that is cleared.
1185  *  This allows the DIR to "reserve" the device before actually
1186  *  starting the job.
1187  */
1188 static bool reserve_device_for_read(DCR *dcr)
1189 {
1190    DEVICE *dev = dcr->dev;
1191    JCR *jcr = dcr->jcr;
1192    bool ok = false;
1193
1194    ASSERT(dcr);
1195
1196    dev->dlock();
1197
1198    if (is_device_unmounted(dev)) {
1199       Dmsg2(dbglvl, "jid=%u Device %s is BLOCKED due to user unmount.\n",
1200          (int)jcr->JobId, dev->print_name());
1201       Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1202            jcr->JobId, dev->print_name());
1203       queue_reserve_message(jcr);
1204       goto bail_out;
1205    }
1206
1207    if (dev->is_busy()) {
1208       Dmsg5(dbglvl, "jid=%u Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1209          (int)jcr->JobId, dev->print_name(),
1210          dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1211       Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1212             jcr->JobId, dev->print_name());
1213       queue_reserve_message(jcr);
1214       goto bail_out;
1215    }
1216
1217    dev->clear_append();
1218    dev->set_read();
1219    ok = true;
1220    dev->reserved_device++;
1221    Dmsg4(dbglvl, "jid=%u Inc reserve=%d dev=%s %p\n", (int)jcr->JobId,
1222       dev->reserved_device, dev->print_name(), dev);
1223    dcr->reserved_device = true;
1224
1225 bail_out:
1226    dev->dunlock();
1227    return ok;
1228 }
1229
1230
1231 /*
1232  * We reserve the device for appending by incrementing the
1233  *  reserved_device. We do virtually all the same work that
1234  *  is done in acquire_device_for_append(), but we do
1235  *  not attempt to mount the device. This routine allows
1236  *  the DIR to reserve multiple devices before *really*
1237  *  starting the job. It also permits the SD to refuse
1238  *  certain devices (not up, ...).
1239  *
1240  * Note, in reserving a device, if the device is for the
1241  *  same pool and the same pool type, then it is acceptable.
1242  *  The Media Type has already been checked. If we are
1243  *  the first tor reserve the device, we put the pool
1244  *  name and pool type in the device record.
1245  */
1246 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1247 {
1248    JCR *jcr = dcr->jcr;
1249    DEVICE *dev = dcr->dev;
1250    bool ok = false;
1251
1252    ASSERT(dcr);
1253
1254    dev->dlock();
1255
1256    /* If device is being read, we cannot write it */
1257    if (dev->can_read()) {
1258       Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1259          jcr->JobId, dev->print_name());
1260       Dmsg2(dbglvl, "jid=%u %s", jid(), jcr->errmsg);
1261       queue_reserve_message(jcr);
1262       goto bail_out;
1263    }
1264
1265    /* If device is unmounted, we are out of luck */
1266    if (is_device_unmounted(dev)) {
1267       Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1268          jcr->JobId, dev->print_name());
1269       Dmsg2(dbglvl, "jid=%u %s", jid(), jcr->errmsg);
1270       queue_reserve_message(jcr);
1271       goto bail_out;
1272    }
1273
1274    Dmsg2(dbglvl, "jid=%u reserve_append device is %s\n",
1275        (int)jcr->JobId, dev->print_name());
1276
1277    /* Now do detailed tests ... */
1278    if (can_reserve_drive(dcr, rctx) != 1) {
1279       Dmsg1(dbglvl, "jid=%u can_reserve_drive!=1\n", (int)jcr->JobId);
1280       goto bail_out;
1281    }
1282
1283    dev->reserved_device++;
1284    Dmsg4(dbglvl, "jid=%u Inc reserve=%d dev=%s %p\n", (int)jcr->JobId, dev->reserved_device,
1285       dev->print_name(), dev);
1286    dcr->reserved_device = true;
1287    ok = true;
1288
1289 bail_out:
1290    dev->dunlock();
1291    return ok;
1292 }
1293
1294 /*
1295  * Returns: 1 if drive can be reserved
1296  *          0 if we should wait
1297  *         -1 on error or impossibility
1298  */
1299 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1300 {
1301    DEVICE *dev = dcr->dev;
1302    JCR *jcr = dcr->jcr;
1303
1304    Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1305          (int)jcr->JobId,
1306          rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1307          rctx.autochanger_only, rctx.any_drive);
1308
1309    /* setting any_drive overrides PreferMountedVols flag */
1310    if (!rctx.any_drive) {
1311       /*
1312        * When PreferMountedVols is set, we keep track of the
1313        *  drive in use that has the least number of writers, then if
1314        *  no unmounted drive is found, we try that drive. This
1315        *  helps spread the load to the least used drives.
1316        */
1317       if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1318          Dmsg3(dbglvl, "jid=%u OK dev=%s == low_drive=%s.\n",
1319             jcr->JobId, dev->print_name(), rctx.low_use_drive->print_name());
1320          return 1;
1321       }
1322       /* If he wants a free drive, but this one is busy, no go */
1323       if (!rctx.PreferMountedVols && dev->is_busy()) {
1324          /* Save least used drive */
1325          if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1326             rctx.num_writers = dev->num_writers + dev->reserved_device;
1327             rctx.low_use_drive = dev;
1328             Dmsg3(dbglvl, "jid=%u set low use drive=%s num_writers=%d\n",
1329                (int)jcr->JobId, dev->print_name(), rctx.num_writers);
1330          } else {
1331             Dmsg2(dbglvl, "jid=%u not low use num_writers=%d\n",
1332                (int)jcr->JobId, dev->num_writers+dev->reserved_device);
1333          }
1334          Dmsg1(dbglvl, "jid=%u failed: !prefMnt && busy.\n", jcr->JobId);
1335          Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1336             jcr->JobId, dev->print_name());
1337          queue_reserve_message(jcr);
1338          return 0;
1339       }
1340
1341       /* Check for prefer mounted volumes */
1342       if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1343          Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1344             jcr->JobId, dev->print_name());
1345          queue_reserve_message(jcr);
1346          Dmsg1(dbglvl, "jid=%u failed: want mounted -- no vol\n", (uint32_t)jcr->JobId);
1347          return 0;                 /* No volume mounted */
1348       }
1349
1350       /* Check for exact Volume name match */
1351       /* ***FIXME*** for Disk, we can accept any volume that goes with this
1352        *    drive.
1353        */
1354       if (rctx.exact_match && rctx.have_volume) {
1355          bool ok;
1356          Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1357                (int)jcr->JobId,
1358                rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1359                rctx.autochanger_only, rctx.any_drive);
1360          Dmsg5(dbglvl, "jid=%u have_vol=%d have=%s resvol=%s want=%s\n",
1361                   (int)jcr->JobId, rctx.have_volume, dev->VolHdr.VolumeName,
1362                   dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1363          ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1364                  (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1365          if (!ok) {
1366             Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1367                jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1368                dev->print_name());
1369             queue_reserve_message(jcr);
1370             Dmsg4(dbglvl, "jid=%u not OK: dev have=%s resvol=%s want=%s\n",
1371                   (int)jcr->JobId, dev->VolHdr.VolumeName,
1372                   dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1373             return 0;
1374          }
1375          if (is_volume_in_use(dcr)) {
1376             return 0;              /* fail if volume on another drive */
1377          }
1378       }
1379    }
1380
1381    /* Check for unused autochanger drive */
1382    if (rctx.autochanger_only && !dev->is_busy() &&
1383        dev->VolHdr.VolumeName[0] == 0) {
1384       /* Device is available but not yet reserved, reserve it for us */
1385       Dmsg2(dbglvl, "jid=%u OK Res Unused autochanger %s.\n",
1386          jcr->JobId, dev->print_name());
1387       bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1388       bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1389       return 1;                       /* reserve drive */
1390    }
1391
1392    /*
1393     * Handle the case that there are no writers
1394     */
1395    if (dev->num_writers == 0) {
1396       /* Now check if there are any reservations on the drive */
1397       if (dev->reserved_device) {
1398          /* Now check if we want the same Pool and pool type */
1399          if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1400              strcmp(dev->pool_type, dcr->pool_type) == 0) {
1401             /* OK, compatible device */
1402             Dmsg2(dbglvl, "jid=%u OK dev: %s num_writers=0, reserved, pool matches\n",
1403                jcr->JobId, dev->print_name());
1404             return 1;
1405          } else {
1406             /* Drive Pool not suitable for us */
1407             Mmsg(jcr->errmsg, _(
1408 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1409                   jcr->JobId, dcr->pool_name, dev->pool_name,
1410                   dev->reserved_device, dev->print_name());
1411             queue_reserve_message(jcr);
1412             Dmsg3(dbglvl, "jid=%u failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1413                (int)jcr->JobId, dev->pool_name, dcr->pool_name);
1414             return 0;                 /* wait */
1415          }
1416       } else if (dev->can_append()) {
1417          /* Device in append mode, check if changing pool */
1418          if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1419              strcmp(dev->pool_type, dcr->pool_type) == 0) {
1420             Dmsg2(dbglvl, "jid=%u OK dev: %s num_writers=0, can_append, pool matches.\n",
1421                jcr->JobId, dev->print_name());
1422             /* OK, compatible device */
1423             return 1;
1424          } else {
1425             /* Changing pool, unload old tape if any in drive */
1426             Dmsg1(dbglvl, "jid=%u OK dev: num_writers=0, not reserved, pool change, unload changer\n",
1427                 (int)jcr->JobId);
1428             unload_autochanger(dcr, 0);
1429          }
1430       }
1431       /* Device is available but not yet reserved, reserve it for us */
1432       Dmsg2(dbglvl, "jid=%u OK Dev avail reserved %s\n", jcr->JobId, dev->print_name());
1433       bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1434       bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1435       return 1;                       /* reserve drive */
1436    }
1437
1438    /*
1439     * Check if the device is in append mode with writers (i.e.
1440     *  available if pool is the same).
1441     */
1442    if (dev->can_append() || dev->num_writers > 0) {
1443       /* Yes, now check if we want the same Pool and pool type */
1444       if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1445           strcmp(dev->pool_type, dcr->pool_type) == 0) {
1446          Dmsg2(dbglvl, "jid=%u OK dev: %s num_writers>=0, can_append, pool matches.\n",
1447             jcr->JobId, dev->print_name());
1448          /* OK, compatible device */
1449          return 1;
1450       } else {
1451          /* Drive Pool not suitable for us */
1452          Mmsg(jcr->errmsg, _("3609 JobId=%u wants Pool=\"%s\" but has Pool=\"%s\" on drive %s.\n"),
1453                jcr->JobId, dcr->pool_name, dev->pool_name, dev->print_name());
1454          queue_reserve_message(jcr);
1455          Dmsg3(dbglvl, "jid=%u failed: busy num_writers>0, can_append, pool=%s wanted=%s\n",
1456             (int)jcr->JobId, dev->pool_name, dcr->pool_name);
1457          return 0;                    /* wait */
1458       }
1459    } else {
1460       Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1461       Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1462             jcr->JobId, dev->print_name());
1463       queue_reserve_message(jcr);
1464       Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1465       return -1;                      /* error, should not get here */
1466    }
1467    Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1468          jcr->JobId, dev->print_name());
1469    queue_reserve_message(jcr);
1470    Dmsg2(dbglvl, "jid=%u failed: No reserve %s\n", jcr->JobId, dev->print_name());
1471    return 0;
1472 }
1473
1474 /*
1475  * search_lock is already set on entering this routine
1476  */
1477 static void queue_reserve_message(JCR *jcr)
1478 {
1479    int i;
1480    alist *msgs = jcr->reserve_msgs;
1481    char *msg;
1482
1483    if (!msgs) {
1484       return;
1485    }
1486    /*
1487     * Look for duplicate message.  If found, do
1488     * not insert
1489     */
1490    for (i=msgs->size()-1; i >= 0; i--) {
1491       msg = (char *)msgs->get(i);
1492       if (!msg) {
1493          return;
1494       }
1495       /* Comparison based on 4 digit message number */
1496       if (strncmp(msg, jcr->errmsg, 4) == 0) {
1497          return;
1498       }
1499    }
1500    /* Message unique, so insert it */
1501    jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1502 }
1503
1504 /*
1505  * Send any reservation messages queued for this jcr
1506  */
1507 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1508 {
1509    int i;
1510    alist *msgs;
1511    char *msg;
1512
1513    lock_reservations();
1514    msgs = jcr->reserve_msgs;
1515    if (!msgs || msgs->size() == 0) {
1516       goto bail_out;
1517    }
1518    for (i=msgs->size()-1; i >= 0; i--) {
1519       msg = (char *)msgs->get(i);
1520       if (msg) {
1521          sendit("   ", 3, arg);
1522          sendit(msg, strlen(msg), arg);
1523       } else {
1524          break;
1525       }
1526    }
1527
1528 bail_out:
1529    unlock_reservations();
1530 }