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

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