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;
 818    Dmsg2(dbglvl, "jid=%u search changers for %s\n", (int)rctx.jcr->JobId,
 819          rctx.device_name);
 820    foreach_res(changer, R_AUTOCHANGER) {
 821       Dmsg2(dbglvl, "jid=%u Try match changer res=%s\n",
 822             (int)rctx.jcr->JobId, changer->hdr.name);
 823       /* Find resource, and make sure we were able to open it */
 824       if (fnmatch(rctx.device_name, changer->hdr.name, 0) == 0) {
 825          DEVRES *device;
 826          /* Try each device in this AutoChanger */
 827          foreach_alist(device, changer->device) {
 828             Dmsg2(dbglvl, "jid=%u Try changer device %s\n",
 829                   (int)rctx.jcr->JobId, device->hdr.name);
 830             if (device->dev == vol->dev) {
 831                Dmsg2(dbglvl, "jid=%u Found changer device %s\n",
 832                      (int)rctx.jcr->JobId, device->hdr.name);
 833                return true;
 834             }
 835          }
 836       }
 837    }
 838    return false;
 839 }
 840
 841 /*
 842  * Search for a device suitable for this job.
 843  */
 844 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
 845 {
 846    bool ok = false;
 847    DIRSTORE *store;
 848    char *device_name;
 849    alist *dirstore;
 850    DCR *dcr = jcr->dcr;
 851
 852    if (rctx.append) {
 853       dirstore = jcr->write_store;
 854    } else {
 855       dirstore = jcr->read_store;
 856    }
 857    Dmsg5(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d\n",
 858       (int)rctx.jcr->JobId,
 859       rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
 860       rctx.autochanger_only);
 861
 862    /*
 863     * If the appropriate conditions of this if are met, namely that
 864     *  we are appending and the user wants mounted drive (or we
 865     *  force try a mounted drive because they are all busy), we
 866     *  start by looking at all the Volumes in the volume list.
 867     */
 868    if (!vol_list->empty() && rctx.append && rctx.PreferMountedVols) {
 869       dlist *temp_vol_list, *save_vol_list;
 870       VOLRES *vol = NULL;
 871       lock_volumes();
 872
 873       /*
 874        * Create a temporary copy of the volume list.  We do this,
 875        *   to avoid having the volume list locked during the
 876        *   call to reserve_device(), which would cause a deadlock.
 877        * Note, we may want to add an update counter on the vol_list
 878        *   so that if it is modified while we are traversing the copy
 879        *   we can take note and act accordingly (probably redo the
 880        *   search at least a few times).
 881        */
 882       Dmsg1(dbglvl, "jid=%u duplicate vol list\n", (int)rctx.jcr->JobId);
 883       temp_vol_list = New(dlist(vol, &vol->link));
 884       foreach_dlist(vol, vol_list) {
 885          VOLRES *nvol;
 886          VOLRES *tvol = (VOLRES *)malloc(sizeof(VOLRES));
 887          memset(tvol, 0, sizeof(VOLRES));
 888          tvol->vol_name = bstrdup(vol->vol_name);
 889          tvol->dev = vol->dev;
 890          nvol = (VOLRES *)temp_vol_list->binary_insert(tvol, my_compare);
 891          if (tvol != nvol) {
 892             tvol->dev = NULL;                   /* don't zap dev entry */
 893             free_vol_item(tvol);
 894             Pmsg0(000, "Logic error. Duplicating vol list hit duplicate.\n");
 895             Jmsg(jcr, M_WARNING, 0, "Logic error. Duplicating vol list hit duplicate.\n");
 896          }
 897       }
 898       unlock_volumes();
 899
 900       /* Look through reserved volumes for one we can use */
 901       Dmsg1(dbglvl, "jid=%u look for vol in vol list\n", (int)rctx.jcr->JobId);
 902       foreach_dlist(vol, temp_vol_list) {
 903          if (!vol->dev) {
 904             Dmsg2(dbglvl, "jid=%u vol=%s no dev\n", (int)rctx.jcr->JobId, vol->vol_name);
 905             continue;
 906          }
 907          /* Check with Director if this Volume is OK */
 908          bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
 909          if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
 910             continue;
 911          }
 912
 913          Dmsg2(dbglvl, "jid=%u vol=%s\n", (int)rctx.jcr->JobId, vol->vol_name);
 914          foreach_alist(store, dirstore) {
 915             int stat;
 916             rctx.store = store;
 917             foreach_alist(device_name, store->device) {
 918                /* Found a device, try to use it */
 919                rctx.device_name = device_name;
 920                rctx.device = vol->dev->device;
 921
 922                if (!vol->dev->is_autochanger()) {
 923                   if (!is_vol_in_autochanger(rctx, vol)) {
 924                      continue;
 925                   }
 926                } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
 927                   Dmsg3(dbglvl, "jid=%u device=%s not suitable want %s\n", (int)rctx.jcr->JobId,
 928                         vol->dev->device->hdr.name, device_name);
 929                   continue;
 930                }
 931
 932                bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
 933                rctx.have_volume = true;
 934                /* Try reserving this device and volume */
 935                Dmsg3(dbglvl, "jid=%u try vol=%s on device=%s\n", (int)rctx.jcr->JobId,
 936                      rctx.VolumeName, device_name);
 937                stat = reserve_device(rctx);
 938                if (stat == 1) {             /* found available device */
 939                   Dmsg2(dbglvl, "jid=%u Suitable device found=%s\n", (int)rctx.jcr->JobId,
 940                         device_name);
 941                   ok = true;
 942                   break;
 943                } else if (stat == 0) {      /* device busy */
 944                   Dmsg2(dbglvl, "jid=%u Suitable device=%s, busy: not use\n",
 945                         (int)rctx.jcr->JobId, device_name);
 946                } else {
 947                   /* otherwise error */
 948                   Dmsg1(dbglvl, "jid=%u No suitable device found.\n", (int)rctx.jcr->JobId);
 949                }
 950                rctx.have_volume = false;
 951             }
 952             if (ok) {
 953                break;
 954             }
 955          }
 956       } /* end for loop over reserved volumes */
 957
 958       lock_volumes();
 959       save_vol_list = vol_list;
 960       vol_list = temp_vol_list;
 961       free_volume_list();                  /* release temp_vol_list */
 962       vol_list = save_vol_list;
 963       Dmsg1(dbglvl, "jid=%u deleted temp vol list\n", (int)rctx.jcr->JobId);
 964       unlock_volumes();
 965    }
 966    if (ok) {
 967       Dmsg2(dbglvl, "jid=%u got vol %s in reserved volums list\n", (int)rctx.jcr->JobId,
 968             rctx.VolumeName);
 969       return true;
 970    }
 971
 972    /*
 973     * No reserved volume we can use, so now search for an available device.
 974     *
 975     * For each storage device that the user specified, we
 976     *  search and see if there is a resource for that device.
 977     */
 978    foreach_alist(store, dirstore) {
 979       rctx.store = store;
 980       foreach_alist(device_name, store->device) {
 981          int stat;
 982          rctx.device_name = device_name;
 983          stat = search_res_for_device(rctx);
 984          if (stat == 1) {             /* found available device */
 985             Dmsg2(dbglvl, "jid=%u available device found=%s\n", (int)rctx.jcr->JobId,
 986                   device_name);
 987             ok = true;
 988             break;
 989          } else if (stat == 0) {      /* device busy */
 990             Dmsg2(dbglvl, "jid=%u Suitable device=%s, busy: not use\n",
 991                   (int)rctx.jcr->JobId, device_name);
 992          } else {
 993             /* otherwise error */
 994             Dmsg1(dbglvl, "jid=%u No suitable device found.\n", (int)rctx.jcr->JobId);
 995          }
 996       }
 997       if (ok) {
 998          break;
 999       }
1000    }
1001    return ok;
1002 }
1003
1004 /*
1005  * Search for a particular storage device with particular storage
1006  *  characteristics (MediaType).
1007  */
1008 int search_res_for_device(RCTX &rctx)
1009 {
1010    AUTOCHANGER *changer;
1011    int stat;
1012
1013    Dmsg2(dbglvl, "jid=%u search res for %s\n", (int)rctx.jcr->JobId, rctx.device_name);
1014    /* Look through Autochangers first */
1015    foreach_res(changer, R_AUTOCHANGER) {
1016       Dmsg2(dbglvl, "jid=%u Try match changer res=%s\n", (int)rctx.jcr->JobId, changer->hdr.name);
1017       /* Find resource, and make sure we were able to open it */
1018       if (fnmatch(rctx.device_name, changer->hdr.name, 0) == 0) {
1019          /* Try each device in this AutoChanger */
1020          foreach_alist(rctx.device, changer->device) {
1021             Dmsg2(dbglvl, "jid=%u Try changer device %s\n", (int)rctx.jcr->JobId,
1022                   rctx.device->hdr.name);
1023             stat = reserve_device(rctx);
1024             if (stat != 1) {             /* try another device */
1025                continue;
1026             }
1027             /* Debug code */
1028             if (rctx.store->append == SD_APPEND) {
1029                Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for append.\n",
1030                   (int)rctx.jcr->JobId, rctx.device->hdr.name,
1031                   rctx.jcr->dcr->dev->reserved_device);
1032             } else {
1033                Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for read.\n",
1034                   (int)rctx.jcr->JobId, rctx.device->hdr.name,
1035                   rctx.jcr->read_dcr->dev->reserved_device);
1036             }
1037             return stat;
1038          }
1039       }
1040    }
1041
1042    /* Now if requested look through regular devices */
1043    if (!rctx.autochanger_only) {
1044       foreach_res(rctx.device, R_DEVICE) {
1045          Dmsg2(dbglvl, "jid=%u Try match res=%s\n", (int)rctx.jcr->JobId, rctx.device->hdr.name);
1046          /* Find resource, and make sure we were able to open it */
1047          if (fnmatch(rctx.device_name, rctx.device->hdr.name, 0) == 0) {
1048             stat = reserve_device(rctx);
1049             if (stat != 1) {             /* try another device */
1050                continue;
1051             }
1052             /* Debug code */
1053             if (rctx.store->append == SD_APPEND) {
1054                Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for append.\n",
1055                   (int)rctx.jcr->JobId, rctx.device->hdr.name,
1056                   rctx.jcr->dcr->dev->reserved_device);
1057             } else {
1058                Dmsg3(dbglvl, "jid=%u Device %s reserved=%d for read.\n",
1059                   (int)rctx.jcr->JobId, rctx.device->hdr.name,
1060                   rctx.jcr->read_dcr->dev->reserved_device);
1061             }
1062             return stat;
1063          }
1064       }
1065    }
1066    return -1;                    /* nothing found */
1067 }
1068
1069 /*
1070  *  Try to reserve a specific device.
1071  *
1072  *  Returns: 1 -- OK, have DCR
1073  *           0 -- must wait
1074  *          -1 -- fatal error
1075  */
1076 static int reserve_device(RCTX &rctx)
1077 {
1078    bool ok;
1079    DCR *dcr;
1080    const int name_len = MAX_NAME_LENGTH;
1081
1082    /* Make sure MediaType is OK */
1083    Dmsg3(dbglvl, "jid=%u chk MediaType device=%s request=%s\n",
1084          (int)rctx.jcr->JobId,
1085          rctx.device->media_type, rctx.store->media_type);
1086    if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
1087       return -1;
1088    }
1089
1090    /* Make sure device exists -- i.e. we can stat() it */
1091    if (!rctx.device->dev) {
1092       rctx.device->dev = init_dev(rctx.jcr, rctx.device);
1093    }
1094    if (!rctx.device->dev) {
1095       if (rctx.device->changer_res) {
1096         Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1097            "     Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
1098              rctx.device->hdr.name, rctx.device_name);
1099       } else {
1100          Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
1101             "     Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
1102               rctx.device_name);
1103       }
1104       return -1;  /* no use waiting */
1105    }
1106
1107    rctx.suitable_device = true;
1108    Dmsg2(dbglvl, "jid=%u try reserve %s\n", rctx.jcr->JobId, rctx.device->hdr.name);
1109    rctx.jcr->dcr = dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
1110    if (!dcr) {
1111       BSOCK *dir = rctx.jcr->dir_bsock;
1112       dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
1113       Dmsg1(dbglvl, ">dird: %s", dir->msg);
1114       return -1;
1115    }
1116    bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
1117    bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
1118    bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
1119    bstrncpy(dcr->dev_name, rctx.device_name, name_len);
1120    if (rctx.store->append == SD_APPEND) {
1121       Dmsg3(dbglvl, "jid=%u have_vol=%d vol=%s\n", (int)rctx.jcr->JobId,
1122           rctx.have_volume, rctx.VolumeName);
1123       ok = reserve_device_for_append(dcr, rctx);
1124       if (!ok) {
1125          goto bail_out;
1126       }
1127
1128       rctx.jcr->dcr = dcr;
1129       Dmsg6(dbglvl, "jid=%u Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1130                (int)rctx.jcr->JobId,
1131                dcr->dev->reserved_device,
1132                dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1133       if (!rctx.have_volume) {
1134          dcr->any_volume = true;
1135          if (dir_find_next_appendable_volume(dcr)) {
1136             bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
1137             Dmsg2(dbglvl, "jid=%u looking for Volume=%s\n", (int)rctx.jcr->JobId, rctx.VolumeName);
1138             rctx.have_volume = true;
1139          } else {
1140             Dmsg1(dbglvl, "jid=%u No next volume found\n", (int)rctx.jcr->JobId);
1141             rctx.have_volume = false;
1142             rctx.VolumeName[0] = 0;
1143             /*
1144              * If there is at least one volume that is valid and in use,
1145              *   but we get here, check if we are running with prefers
1146              *   non-mounted drives.  In that case, we have selected a
1147              *   non-used drive and our one and only volume is mounted
1148              *   elsewhere, so we bail out and retry using that drive.
1149              */
1150             if (dcr->volume_in_use && !rctx.PreferMountedVols) {
1151                rctx.PreferMountedVols = true;
1152                goto bail_out;
1153             }
1154          }
1155       }
1156    } else {
1157       ok = reserve_device_for_read(dcr);
1158       if (ok) {
1159          rctx.jcr->read_dcr = dcr;
1160          Dmsg6(dbglvl, "jid=%u Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
1161                (int)rctx.jcr->JobId,
1162                dcr->dev->reserved_device,
1163                dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
1164       }
1165    }
1166    if (!ok) {
1167       goto bail_out;
1168    }
1169    if (rctx.notify_dir) {
1170       POOL_MEM dev_name;
1171       BSOCK *dir = rctx.jcr->dir_bsock;
1172       pm_strcpy(dev_name, rctx.device->hdr.name);
1173       bash_spaces(dev_name);
1174       ok = dir->fsend(OK_device, dev_name.c_str());  /* Return real device name */
1175       Dmsg2(dbglvl, "jid=%u >dird changer: %s", jid(), dir->msg);
1176    } else {
1177       ok = true;
1178    }
1179    return ok ? 1 : -1;
1180
1181 bail_out:
1182    rctx.have_volume = false;
1183 // free_dcr(dcr);
1184    Dmsg1(dbglvl, "jid=%u Not OK.\n", (int)rctx.jcr->JobId);
1185    return 0;
1186 }
1187
1188 /*
1189  * We "reserve" the drive by setting the ST_READ bit. No one else
1190  *  should touch the drive until that is cleared.
1191  *  This allows the DIR to "reserve" the device before actually
1192  *  starting the job.
1193  */
1194 static bool reserve_device_for_read(DCR *dcr)
1195 {
1196    DEVICE *dev = dcr->dev;
1197    JCR *jcr = dcr->jcr;
1198    bool ok = false;
1199
1200    ASSERT(dcr);
1201
1202    dev->dlock();
1203
1204    if (is_device_unmounted(dev)) {
1205       Dmsg2(dbglvl, "jid=%u Device %s is BLOCKED due to user unmount.\n",
1206          (int)jcr->JobId, dev->print_name());
1207       Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1208            jcr->JobId, dev->print_name());
1209       queue_reserve_message(jcr);
1210       goto bail_out;
1211    }
1212
1213    if (dev->is_busy()) {
1214       Dmsg5(dbglvl, "jid=%u Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
1215          (int)jcr->JobId, dev->print_name(),
1216          dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
1217       Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
1218             jcr->JobId, dev->print_name());
1219       queue_reserve_message(jcr);
1220       goto bail_out;
1221    }
1222
1223    dev->clear_append();
1224    dev->set_read();
1225    ok = true;
1226    dev->reserved_device++;
1227    Dmsg4(dbglvl, "jid=%u Inc reserve=%d dev=%s %p\n", (int)jcr->JobId,
1228       dev->reserved_device, dev->print_name(), dev);
1229    dcr->reserved_device = true;
1230
1231 bail_out:
1232    dev->dunlock();
1233    return ok;
1234 }
1235
1236
1237 /*
1238  * We reserve the device for appending by incrementing the
1239  *  reserved_device. We do virtually all the same work that
1240  *  is done in acquire_device_for_append(), but we do
1241  *  not attempt to mount the device. This routine allows
1242  *  the DIR to reserve multiple devices before *really*
1243  *  starting the job. It also permits the SD to refuse
1244  *  certain devices (not up, ...).
1245  *
1246  * Note, in reserving a device, if the device is for the
1247  *  same pool and the same pool type, then it is acceptable.
1248  *  The Media Type has already been checked. If we are
1249  *  the first tor reserve the device, we put the pool
1250  *  name and pool type in the device record.
1251  */
1252 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
1253 {
1254    JCR *jcr = dcr->jcr;
1255    DEVICE *dev = dcr->dev;
1256    bool ok = false;
1257
1258    ASSERT(dcr);
1259
1260    dev->dlock();
1261
1262    /* If device is being read, we cannot write it */
1263    if (dev->can_read()) {
1264       Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
1265          jcr->JobId, dev->print_name());
1266       Dmsg2(dbglvl, "jid=%u %s", jid(), jcr->errmsg);
1267       queue_reserve_message(jcr);
1268       goto bail_out;
1269    }
1270
1271    /* If device is unmounted, we are out of luck */
1272    if (is_device_unmounted(dev)) {
1273       Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
1274          jcr->JobId, dev->print_name());
1275       Dmsg2(dbglvl, "jid=%u %s", jid(), jcr->errmsg);
1276       queue_reserve_message(jcr);
1277       goto bail_out;
1278    }
1279
1280    Dmsg2(dbglvl, "jid=%u reserve_append device is %s\n",
1281        (int)jcr->JobId, dev->print_name());
1282
1283    /* Now do detailed tests ... */
1284    if (can_reserve_drive(dcr, rctx) != 1) {
1285       Dmsg1(dbglvl, "jid=%u can_reserve_drive!=1\n", (int)jcr->JobId);
1286       goto bail_out;
1287    }
1288
1289    dev->reserved_device++;
1290    Dmsg4(dbglvl, "jid=%u Inc reserve=%d dev=%s %p\n", (int)jcr->JobId, dev->reserved_device,
1291       dev->print_name(), dev);
1292    dcr->reserved_device = true;
1293    ok = true;
1294
1295 bail_out:
1296    dev->dunlock();
1297    return ok;
1298 }
1299
1300 /*
1301  * Returns: 1 if drive can be reserved
1302  *          0 if we should wait
1303  *         -1 on error or impossibility
1304  */
1305 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
1306 {
1307    DEVICE *dev = dcr->dev;
1308    JCR *jcr = dcr->jcr;
1309
1310    Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1311          (int)jcr->JobId,
1312          rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1313          rctx.autochanger_only, rctx.any_drive);
1314
1315    /* setting any_drive overrides PreferMountedVols flag */
1316    if (!rctx.any_drive) {
1317       /*
1318        * When PreferMountedVols is set, we keep track of the
1319        *  drive in use that has the least number of writers, then if
1320        *  no unmounted drive is found, we try that drive. This
1321        *  helps spread the load to the least used drives.
1322        */
1323       if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
1324          Dmsg3(dbglvl, "jid=%u OK dev=%s == low_drive=%s.\n",
1325             jcr->JobId, dev->print_name(), rctx.low_use_drive->print_name());
1326          return 1;
1327       }
1328       /* If he wants a free drive, but this one is busy, no go */
1329       if (!rctx.PreferMountedVols && dev->is_busy()) {
1330          /* Save least used drive */
1331          if ((dev->num_writers + dev->reserved_device) < rctx.num_writers) {
1332             rctx.num_writers = dev->num_writers + dev->reserved_device;
1333             rctx.low_use_drive = dev;
1334             Dmsg3(dbglvl, "jid=%u set low use drive=%s num_writers=%d\n",
1335                (int)jcr->JobId, dev->print_name(), rctx.num_writers);
1336          } else {
1337             Dmsg2(dbglvl, "jid=%u not low use num_writers=%d\n",
1338                (int)jcr->JobId, dev->num_writers+dev->reserved_device);
1339          }
1340          Dmsg1(dbglvl, "jid=%u failed: !prefMnt && busy.\n", jcr->JobId);
1341          Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
1342             jcr->JobId, dev->print_name());
1343          queue_reserve_message(jcr);
1344          return 0;
1345       }
1346
1347       /* Check for prefer mounted volumes */
1348       if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
1349          Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
1350             jcr->JobId, dev->print_name());
1351          queue_reserve_message(jcr);
1352          Dmsg1(dbglvl, "jid=%u failed: want mounted -- no vol\n", (uint32_t)jcr->JobId);
1353          return 0;                 /* No volume mounted */
1354       }
1355
1356       /* Check for exact Volume name match */
1357       /* ***FIXME*** for Disk, we can accept any volume that goes with this
1358        *    drive.
1359        */
1360       if (rctx.exact_match && rctx.have_volume) {
1361          bool ok;
1362          Dmsg6(dbglvl, "jid=%u PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
1363                (int)jcr->JobId,
1364                rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
1365                rctx.autochanger_only, rctx.any_drive);
1366          Dmsg5(dbglvl, "jid=%u have_vol=%d have=%s resvol=%s want=%s\n",
1367                   (int)jcr->JobId, rctx.have_volume, dev->VolHdr.VolumeName,
1368                   dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1369          ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
1370                  (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
1371          if (!ok) {
1372             Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
1373                jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
1374                dev->print_name());
1375             queue_reserve_message(jcr);
1376             Dmsg4(dbglvl, "jid=%u not OK: dev have=%s resvol=%s want=%s\n",
1377                   (int)jcr->JobId, dev->VolHdr.VolumeName,
1378                   dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1379             return 0;
1380          }
1381          if (is_volume_in_use(dcr)) {
1382             return 0;              /* fail if volume on another drive */
1383          }
1384       }
1385    }
1386
1387    /* Check for unused autochanger drive */
1388    if (rctx.autochanger_only && !dev->is_busy() &&
1389        dev->VolHdr.VolumeName[0] == 0) {
1390       /* Device is available but not yet reserved, reserve it for us */
1391       Dmsg2(dbglvl, "jid=%u OK Res Unused autochanger %s.\n",
1392          jcr->JobId, dev->print_name());
1393       bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1394       bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1395       return 1;                       /* reserve drive */
1396    }
1397
1398    /*
1399     * Handle the case that there are no writers
1400     */
1401    if (dev->num_writers == 0) {
1402       /* Now check if there are any reservations on the drive */
1403       if (dev->reserved_device) {
1404          /* Now check if we want the same Pool and pool type */
1405          if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1406              strcmp(dev->pool_type, dcr->pool_type) == 0) {
1407             /* OK, compatible device */
1408             Dmsg2(dbglvl, "jid=%u OK dev: %s num_writers=0, reserved, pool matches\n",
1409                jcr->JobId, dev->print_name());
1410             return 1;
1411          } else {
1412             /* Drive Pool not suitable for us */
1413             Mmsg(jcr->errmsg, _(
1414 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
1415                   jcr->JobId, dcr->pool_name, dev->pool_name,
1416                   dev->reserved_device, dev->print_name());
1417             queue_reserve_message(jcr);
1418             Dmsg3(dbglvl, "jid=%u failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
1419                (int)jcr->JobId, dev->pool_name, dcr->pool_name);
1420             return 0;                 /* wait */
1421          }
1422       } else if (dev->can_append()) {
1423          /* Device in append mode, check if changing pool */
1424          if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1425              strcmp(dev->pool_type, dcr->pool_type) == 0) {
1426             Dmsg2(dbglvl, "jid=%u OK dev: %s num_writers=0, can_append, pool matches.\n",
1427                jcr->JobId, dev->print_name());
1428             /* OK, compatible device */
1429             return 1;
1430          } else {
1431             /* Changing pool, unload old tape if any in drive */
1432             Dmsg1(dbglvl, "jid=%u OK dev: num_writers=0, not reserved, pool change, unload changer\n",
1433                 (int)jcr->JobId);
1434             unload_autochanger(dcr, 0);
1435          }
1436       }
1437       /* Device is available but not yet reserved, reserve it for us */
1438       Dmsg2(dbglvl, "jid=%u OK Dev avail reserved %s\n", jcr->JobId, dev->print_name());
1439       bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1440       bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1441       return 1;                       /* reserve drive */
1442    }
1443
1444    /*
1445     * Check if the device is in append mode with writers (i.e.
1446     *  available if pool is the same).
1447     */
1448    if (dev->can_append() || dev->num_writers > 0) {
1449       /* Yes, now check if we want the same Pool and pool type */
1450       if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
1451           strcmp(dev->pool_type, dcr->pool_type) == 0) {
1452          Dmsg2(dbglvl, "jid=%u OK dev: %s num_writers>=0, can_append, pool matches.\n",
1453             jcr->JobId, dev->print_name());
1454          /* OK, compatible device */
1455          return 1;
1456       } else {
1457          /* Drive Pool not suitable for us */
1458          Mmsg(jcr->errmsg, _("3609 JobId=%u wants Pool=\"%s\" but has Pool=\"%s\" on drive %s.\n"),
1459                jcr->JobId, dcr->pool_name, dev->pool_name, dev->print_name());
1460          queue_reserve_message(jcr);
1461          Dmsg3(dbglvl, "jid=%u failed: busy num_writers>0, can_append, pool=%s wanted=%s\n",
1462             (int)jcr->JobId, dev->pool_name, dcr->pool_name);
1463          return 0;                    /* wait */
1464       }
1465    } else {
1466       Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1467       Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1468             jcr->JobId, dev->print_name());
1469       queue_reserve_message(jcr);
1470       Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1471       return -1;                      /* error, should not get here */
1472    }
1473    Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1474          jcr->JobId, dev->print_name());
1475    queue_reserve_message(jcr);
1476    Dmsg2(dbglvl, "jid=%u failed: No reserve %s\n", jcr->JobId, dev->print_name());
1477    return 0;
1478 }
1479
1480 /*
1481  * search_lock is already set on entering this routine
1482  */
1483 static void queue_reserve_message(JCR *jcr)
1484 {
1485    int i;
1486    alist *msgs = jcr->reserve_msgs;
1487    char *msg;
1488
1489    if (!msgs) {
1490       return;
1491    }
1492    /*
1493     * Look for duplicate message.  If found, do
1494     * not insert
1495     */
1496    for (i=msgs->size()-1; i >= 0; i--) {
1497       msg = (char *)msgs->get(i);
1498       if (!msg) {
1499          return;
1500       }
1501       /* Comparison based on 4 digit message number */
1502       if (strncmp(msg, jcr->errmsg, 4) == 0) {
1503          return;
1504       }
1505    }
1506    /* Message unique, so insert it */
1507    jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1508 }
1509
1510 /*
1511  * Send any reservation messages queued for this jcr
1512  */
1513 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1514 {
1515    int i;
1516    alist *msgs;
1517    char *msg;
1518
1519    lock_reservations();
1520    msgs = jcr->reserve_msgs;
1521    if (!msgs || msgs->size() == 0) {
1522       goto bail_out;
1523    }
1524    for (i=msgs->size()-1; i >= 0; i--) {
1525       msg = (char *)msgs->get(i);
1526       if (msg) {
1527          sendit("   ", 3, arg);
1528          sendit(msg, strlen(msg), arg);
1529       } else {
1530          break;
1531       }
1532    }
1533
1534 bail_out:
1535    unlock_reservations();
1536 }