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

   1 /*
   2  *   Drive reservation functions for Storage Daemon
   3  *
   4  *   Kern Sibbald, MM
   5  *
   6  *   Split from job.c and acquire.c June 2005
   7  *
   8  *   Version $Id$
   9  *
  10  */
  11 /*
  12    Copyright (C) 2000-2005 Kern Sibbald
  13
  14    This program is free software; you can redistribute it and/or
  15    modify it under the terms of the GNU General Public License
  16    version 2 as amended with additional clauses defined in the
  17    file LICENSE in the main source directory.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  22    the file LICENSE for additional details.
  23
  24  */
  25
  26 #include "bacula.h"
  27 #include "stored.h"
  28
  29 /*
  30  *   Use Device command from Director
  31  *   He tells is what Device Name to use, the Media Type,
  32  *      the Pool Name, and the Pool Type.
  33  *
  34  *    Ensure that the device exists and is opened, then store
  35  *      the media and pool info in the JCR.  This class is used
  36  *      only temporarily in this file.
  37  */
  38 class DIRSTORE {
  39 public:
  40    alist *device;
  41    bool append;
  42    char name[MAX_NAME_LENGTH];
  43    char media_type[MAX_NAME_LENGTH];
  44    char pool_name[MAX_NAME_LENGTH];
  45    char pool_type[MAX_NAME_LENGTH];
  46 };
  47
  48 /* Reserve context */
  49 class RCTX {
  50 public:
  51    alist *errors;
  52    JCR *jcr;
  53    char *device_name;
  54    DIRSTORE *store;
  55    DEVRES   *device;
  56    bool PreferMountedVols;
  57    bool exact_match;
  58    bool have_volume;
  59    bool do_not_wait;
  60    bool available_autochanger;
  61    char VolumeName[MAX_NAME_LENGTH];
  62 };
  63
  64 static dlist *vol_list = NULL;
  65 static pthread_mutex_t vol_list_lock = PTHREAD_MUTEX_INITIALIZER;
  66 static pthread_mutex_t search_lock = PTHREAD_MUTEX_INITIALIZER;
  67
  68 /* Forward referenced functions */
  69 static int can_reserve_drive(DCR *dcr, RCTX &rctx);
  70 static int search_res_for_device(RCTX &rctx);
  71 static int reserve_device(RCTX &rctx);
  72 static bool reserve_device_for_read(DCR *dcr);
  73 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx);
  74 static bool use_storage_cmd(JCR *jcr);
  75 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx);
  76
  77 /* Requests from the Director daemon */
  78 static char use_storage[]  = "use storage=%127s media_type=%127s "
  79    "pool_name=%127s pool_type=%127s append=%d copy=%d stripe=%d\n";
  80 static char use_device[]  = "use device=%127s\n";
  81
  82 /* Responses sent to Director daemon */
  83 static char OK_device[] = "3000 OK use device device=%s\n";
  84 static char NO_device[] = "3924 Device \"%s\" not in SD Device resources.\n";
  85 static char BAD_use[]   = "3913 Bad use command: %s\n";
  86
  87 bool use_cmd(JCR *jcr)
  88 {
  89    /*
  90     * Get the device, media, and pool information
  91     */
  92    if (!use_storage_cmd(jcr)) {
  93       set_jcr_job_status(jcr, JS_ErrorTerminated);
  94       memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
  95       return false;
  96    }
  97    return true;
  98 }
  99
 100 static int my_compare(void *item1, void *item2)
 101 {
 102    return strcmp(((VOLRES *)item1)->vol_name, ((VOLRES *)item2)->vol_name);
 103 }
 104
 105
 106 /*
 107  * Put a new Volume entry in the Volume list. This
 108  *  effectively reserves the volume so that it will
 109  *  not be mounted again.
 110  *
 111  *  Return: VOLRES entry on success
 112  *          NULL if the Volume is already in the list
 113  */
 114 VOLRES *new_volume(DCR *dcr, const char *VolumeName)
 115 {
 116    VOLRES *vol, *nvol;
 117
 118    Dmsg1(400, "new_volume %s\n", VolumeName);
 119    P(vol_list_lock);
 120    if (dcr->dev) {
 121 again:
 122       foreach_dlist(vol, vol_list) {
 123          if (vol && vol->dev == dcr->dev) {
 124             vol_list->remove(vol);
 125             if (vol->vol_name) {
 126                free(vol->vol_name);
 127             }
 128             free(vol);
 129             goto again;
 130          }
 131       }
 132    }
 133    vol = (VOLRES *)malloc(sizeof(VOLRES));
 134    memset(vol, 0, sizeof(VOLRES));
 135    vol->vol_name = bstrdup(VolumeName);
 136    vol->dev = dcr->dev;
 137    vol->dcr = dcr;
 138    nvol = (VOLRES *)vol_list->binary_insert(vol, my_compare);
 139    if (nvol != vol) {
 140       free(vol->vol_name);
 141       free(vol);
 142       vol = NULL;
 143       if (dcr->dev) {
 144          nvol->dev = dcr->dev;
 145       }
 146    }
 147    V(vol_list_lock);
 148    return vol;
 149 }
 150
 151 /*
 152  * Search for a Volume name in the Volume list.
 153  *
 154  *  Returns: VOLRES entry on success
 155  *           NULL if the Volume is not in the list
 156  */
 157 VOLRES *find_volume(const char *VolumeName)
 158 {
 159    VOLRES vol, *fvol;
 160    P(vol_list_lock);
 161    vol.vol_name = bstrdup(VolumeName);
 162    fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
 163    free(vol.vol_name);
 164    V(vol_list_lock);
 165    return fvol;
 166 }
 167
 168 /*
 169  * Free a Volume from the Volume list
 170  *
 171  *  Returns: true if the Volume found and removed from the list
 172  *           false if the Volume is not in the list
 173  */
 174 bool free_volume(DEVICE *dev)
 175 {
 176    VOLRES vol, *fvol;
 177
 178   P(vol_list_lock);
 179    if (dev->VolHdr.VolumeName[0] == 0) {
 180       /*
 181        * Our device has no VolumeName listed, but
 182        *  search the list for any Volume attached to
 183        *  this device and remove it.
 184        */
 185       foreach_dlist(fvol, vol_list) {
 186          if (fvol && fvol->dev == dev) {
 187             vol_list->remove(fvol);
 188             if (fvol->vol_name) {
 189                free(fvol->vol_name);
 190             }
 191             free(fvol);
 192             break;
 193          }
 194       }
 195       goto bail_out;
 196    }
 197    Dmsg1(400, "free_volume %s\n", dev->VolHdr.VolumeName);
 198    vol.vol_name = bstrdup(dev->VolHdr.VolumeName);
 199    fvol = (VOLRES *)vol_list->binary_search(&vol, my_compare);
 200    if (fvol) {
 201       vol_list->remove(fvol);
 202       free(fvol->vol_name);
 203       free(fvol);
 204    }
 205    free(vol.vol_name);
 206    dev->VolHdr.VolumeName[0] = 0;
 207 bail_out:
 208    V(vol_list_lock);
 209    return fvol != NULL;
 210 }
 211
 212 /* Free volume reserved by this dcr but not attached to a dev */
 213 void free_unused_volume(DCR *dcr)
 214 {
 215    VOLRES *vol;
 216    P(vol_list_lock);
 217    for (vol=(VOLRES *)vol_list->first(); vol; vol=(VOLRES *)vol_list->next(vol)) {
 218       if (vol->dcr == dcr && (vol->dev == NULL ||
 219           strcmp(vol->vol_name, vol->dev->VolHdr.VolumeName) != 0)) {
 220          vol_list->remove(vol);
 221          free(vol->vol_name);
 222          free(vol);
 223          break;
 224       }
 225    }
 226    V(vol_list_lock);
 227 }
 228
 229 /*
 230  * List Volumes -- this should be moved to status.c
 231  */
 232 void list_volumes(BSOCK *user)
 233 {
 234    VOLRES *vol;
 235    for (vol=(VOLRES *)vol_list->first(); vol; vol=(VOLRES *)vol_list->next(vol)) {
 236       if (vol->dev) {
 237          bnet_fsend(user, "%s on device %s\n", vol->vol_name, vol->dev->print_name());
 238       } else {
 239          bnet_fsend(user, "%s\n", vol->vol_name);
 240       }
 241    }
 242 }
 243
 244 /* Create the Volume list */
 245 void create_volume_list()
 246 {
 247    VOLRES *dummy = NULL;
 248    if (vol_list == NULL) {
 249       vol_list = New(dlist(dummy, &dummy->link));
 250    }
 251 }
 252
 253 /* Release all Volumes from the list */
 254 void free_volume_list()
 255 {
 256    VOLRES *vol;
 257    if (!vol_list) {
 258       return;
 259    }
 260    for (vol=(VOLRES *)vol_list->first(); vol; vol=(VOLRES *)vol_list->next(vol)) {
 261       Dmsg3(000, "Unreleased Volume=%s dcr=0x%x dev=0x%x\n", vol->vol_name,
 262          vol->dcr, vol->dev);
 263    }
 264    delete vol_list;
 265    vol_list = NULL;
 266 }
 267
 268 bool is_volume_in_use(DCR *dcr)
 269 {
 270    VOLRES *vol = find_volume(dcr->VolumeName);
 271    if (!vol) {
 272       return false;                   /* vol not in list */
 273    }
 274    if (!vol->dev) {                   /* vol not attached to device */
 275       return false;
 276    }
 277    if (dcr->dev == vol->dev) {        /* same device OK */
 278       return false;
 279    }
 280    if (!vol->dev->is_busy()) {
 281       return false;
 282    }
 283    return true;
 284 }
 285
 286
 287 static bool use_storage_cmd(JCR *jcr)
 288 {
 289    POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
 290    BSOCK *dir = jcr->dir_bsock;
 291    int append;
 292    bool ok;
 293    int Copy, Stripe;
 294    DIRSTORE *store;
 295    RCTX rctx;
 296 #ifdef implemented
 297    char *error;
 298 #endif
 299
 300    memset(&rctx, 0, sizeof(RCTX));
 301    rctx.jcr = jcr;
 302    /*
 303     * If there are multiple devices, the director sends us
 304     *   use_device for each device that it wants to use.
 305     */
 306    jcr->dirstore = New(alist(10, not_owned_by_alist));
 307    do {
 308       Dmsg1(100, "<dird: %s", dir->msg);
 309       ok = sscanf(dir->msg, use_storage, store_name.c_str(),
 310                   media_type.c_str(), pool_name.c_str(),
 311                   pool_type.c_str(), &append, &Copy, &Stripe) == 7;
 312       if (!ok) {
 313          break;
 314       }
 315       unbash_spaces(store_name);
 316       unbash_spaces(media_type);
 317       unbash_spaces(pool_name);
 318       unbash_spaces(pool_type);
 319       store = new DIRSTORE;
 320       jcr->dirstore->append(store);
 321       memset(store, 0, sizeof(DIRSTORE));
 322       store->device = New(alist(10));
 323       bstrncpy(store->name, store_name, sizeof(store->name));
 324       bstrncpy(store->media_type, media_type, sizeof(store->media_type));
 325       bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
 326       bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
 327       store->append = append;
 328
 329       /* Now get all devices */
 330       while (bnet_recv(dir) >= 0) {
 331          Dmsg1(100, "<dird device: %s", dir->msg);
 332          ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
 333          if (!ok) {
 334             break;
 335          }
 336          unbash_spaces(dev_name);
 337          store->device->append(bstrdup(dev_name.c_str()));
 338       }
 339    }  while (ok && bnet_recv(dir) >= 0);
 340
 341 #ifdef DEVELOPER
 342    /* This loop is debug code and can be removed */
 343    /* ***FIXME**** remove after 1.38 release */
 344    char *device_name;
 345    foreach_alist(store, jcr->dirstore) {
 346       Dmsg4(100, "Storage=%s media_type=%s pool=%s pool_type=%s\n",
 347          store->name, store->media_type, store->pool_name,
 348          store->pool_type);
 349       foreach_alist(device_name, store->device) {
 350          Dmsg1(100, "   Device=%s\n", device_name);
 351       }
 352    }
 353 #endif
 354
 355    /*
 356     * At this point, we have a list of all the Director's Storage
 357     *  resources indicated for this Job, which include Pool, PoolType,
 358     *  storage name, and Media type.
 359     * Then for each of the Storage resources, we have a list of
 360     *  device names that were given.
 361     *
 362     * Wiffle through them and find one that can do the backup.
 363     */
 364    if (ok) {
 365 #ifdef OLD_ALGORITHM
 366       /*
 367        * First look for an exact match of Volume name as the
 368        *  tape may already be mounted.
 369        */
 370       rctx.do_not_wait = true;
 371       rctx.exact_match = true;
 372       if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 373          goto done;
 374       }
 375       rctx.exact_match = false;
 376
 377       /* Now search if an unused autochanger slot is available */
 378       rctx.available_autochanger = true;
 379       if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 380          goto done;
 381       }
 382       rctx.available_autochanger = false;
 383
 384
 385       /*
 386        * Make up to two passes. The first with PreferMountedVols possibly
 387        *   set to true.  In that case, we look only for an available
 388        *   drive with something mounted. If that fails, then we
 389        *   do a second pass with PerferMountedVols set false.
 390        */
 391       rctx.PreferMountedVols = jcr->PreferMountedVols;
 392       if (!rctx.PreferMountedVols) {
 393          rctx.do_not_wait = false;
 394       }
 395       if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 396          goto done;
 397       }
 398       if (rctx.PreferMountedVols) {
 399          rctx.PreferMountedVols = false;
 400          rctx.do_not_wait = false;
 401          if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 402             goto done;
 403          }
 404       }
 405 #else /* NEW SEARCH ALGORITHM */
 406       rctx.do_not_wait = true;
 407       if (!jcr->PreferMountedVols) {
 408          /* Look for unused drives in autochangers */
 409          rctx.PreferMountedVols = false;
 410          rctx.exact_match = false;
 411          rctx.available_autochanger = true;
 412          if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 413             goto done;
 414          }
 415          /* Look through all drives */
 416          rctx.available_autochanger = false;
 417          if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 418             goto done;
 419          }
 420       }
 421       /* Look for an exact match all drives */
 422       rctx.PreferMountedVols = true;
 423       rctx.exact_match = true;
 424       rctx.available_autochanger = false;
 425       if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 426          goto done;
 427       }
 428       /* Wait for any drive anywhere */
 429       rctx.exact_match = false;
 430       rctx.do_not_wait = false;
 431       if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 432          goto done;
 433       }
 434 #endif
 435       if (verbose) {
 436          unbash_spaces(dir->msg);
 437          pm_strcpy(jcr->errmsg, dir->msg);
 438          Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
 439       }
 440       Jmsg(jcr, M_FATAL, 0, _("\n"
 441          "     Device \"%s\" with MediaType \"%s\" requested by DIR not found in SD Device resources.\n"),
 442            dev_name.c_str(), media_type.c_str());
 443       bnet_fsend(dir, NO_device, dev_name.c_str());
 444 #ifdef implemented
 445       for (error=(char*)rctx->errors.first(); error;
 446            error=(char*)rctx->errors.next()) {
 447          Jmsg(jcr, M_INFO, 0, "%s", error);
 448       }
 449 #endif
 450       Dmsg1(100, ">dird: %s", dir->msg);
 451    } else {
 452       unbash_spaces(dir->msg);
 453       pm_strcpy(jcr->errmsg, dir->msg);
 454       if (verbose) {
 455          Jmsg(jcr, M_INFO, 0, _("Failed command: %s\n"), jcr->errmsg);
 456       }
 457       bnet_fsend(dir, BAD_use, jcr->errmsg);
 458       Dmsg1(100, ">dird: %s", dir->msg);
 459    }
 460
 461 done:
 462    foreach_alist(store, jcr->dirstore) {
 463       delete store->device;
 464       delete store;
 465    }
 466    delete jcr->dirstore;
 467 #ifdef implemented
 468    for (error=(char*)rctx->errors.first(); error;
 469         error=(char*)rctx->errors.next()) {
 470       free(error);
 471    }
 472 #endif
 473    return ok;
 474 }
 475
 476
 477 /*
 478  * Search for a device suitable for this job.
 479  */
 480 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
 481 {
 482    bool first = true;
 483    bool ok;
 484    DIRSTORE *store;
 485    char *device_name;
 486
 487    Dmsg4(100, "PrefMnt=%d exact=%d no_wait=%d availchgr=%d\n",
 488       rctx.PreferMountedVols, rctx.exact_match, rctx.do_not_wait,
 489       rctx.available_autochanger);
 490    init_jcr_device_wait_timers(jcr);
 491    for ( ;; ) {
 492       int can_wait = false;
 493       ok = false;
 494       P(search_lock);
 495       foreach_alist(store, jcr->dirstore) {
 496          rctx.store = store;
 497          foreach_alist(device_name, store->device) {
 498             int stat;
 499             rctx.device_name = device_name;
 500             stat = search_res_for_device(rctx);
 501             if (stat == 1) {             /* found available device */
 502                ok = true;
 503                break;
 504             } else if (stat == 0) {      /* device busy */
 505                can_wait = true;
 506             }
 507             /* otherwise error */
 508 //             rctx->errors.push(bstrdup(jcr->errmsg));
 509          }
 510          if (ok) {
 511             break;
 512          }
 513       }
 514       V(search_lock);
 515       /*
 516        * We did not find a suitable device, so
 517        *  if there is some device for which we can wait, then
 518        *  wait and try again until the wait time expires
 519        */
 520       if (rctx.do_not_wait || !can_wait || !wait_for_device(jcr, first)) {
 521          break;
 522       }
 523       first = false;                  /* first wait complete */
 524
 525 #ifdef implemented
 526       for (error=(char*)rctx->errors.first(); error;
 527            error=(char*)rctx->errors.next()) {
 528          free(error);
 529       }
 530 #endif
 531    }
 532    return ok;
 533 }
 534
 535 /*
 536  * Search for a particular storage device with particular storage
 537  *  characteristics (MediaType).
 538  */
 539 static int search_res_for_device(RCTX &rctx)
 540 {
 541    AUTOCHANGER *changer;
 542    BSOCK *dir = rctx.jcr->dir_bsock;
 543    bool ok;
 544    int stat;
 545
 546    Dmsg1(100, "Search res for %s\n", rctx.device_name);
 547    if (!rctx.available_autochanger) {
 548       foreach_res(rctx.device, R_DEVICE) {
 549          Dmsg1(100, "Try res=%s\n", rctx.device->hdr.name);
 550          /* Find resource, and make sure we were able to open it */
 551          if (fnmatch(rctx.device_name, rctx.device->hdr.name, 0) == 0) {
 552             stat = reserve_device(rctx);
 553             if (stat != 1) {
 554                return stat;
 555             }
 556             Dmsg1(220, "Got: %s", dir->msg);
 557             bash_spaces(rctx.device_name);
 558             ok = bnet_fsend(dir, OK_device, rctx.device_name);
 559             Dmsg1(100, ">dird dev: %s", dir->msg);
 560             return ok ? 1 : -1;
 561          }
 562       }
 563    }
 564    foreach_res(changer, R_AUTOCHANGER) {
 565       Dmsg1(100, "Try changer res=%s\n", changer->hdr.name);
 566       /* Find resource, and make sure we were able to open it */
 567       if (fnmatch(rctx.device_name, changer->hdr.name, 0) == 0) {
 568          /* Try each device in this AutoChanger */
 569          foreach_alist(rctx.device, changer->device) {
 570             Dmsg1(100, "Try changer device %s\n", rctx.device->hdr.name);
 571             stat = reserve_device(rctx);
 572             if (stat != 1) {             /* try another device */
 573                continue;
 574             }
 575             POOL_MEM dev_name;
 576             if (rctx.store->append == SD_APPEND) {
 577                Dmsg2(100, "Device %s reserved=%d.\n", rctx.device_name,
 578                   rctx.jcr->dcr->dev->reserved_device);
 579             } else {
 580                Dmsg2(100, "Device %s reserved=%d.\n", rctx.device_name,
 581                   rctx.jcr->read_dcr->dev->reserved_device);
 582             }
 583             pm_strcpy(dev_name, rctx.device->hdr.name);
 584             bash_spaces(dev_name);
 585             ok = bnet_fsend(dir, OK_device, dev_name.c_str());  /* Return real device name */
 586             Dmsg1(100, ">dird changer: %s", dir->msg);
 587             return ok ? 1 : -1;
 588          }
 589       }
 590    }
 591    return 0;                    /* nothing found */
 592 }
 593
 594 /*
 595  *  Try to reserve a specific device.
 596  *
 597  *  Returns: 1 -- OK, have DCR
 598  *           0 -- must wait
 599  *          -1 -- fatal error
 600  */
 601 static int reserve_device(RCTX &rctx)
 602 {
 603    bool ok;
 604    DCR *dcr;
 605    const int name_len = MAX_NAME_LENGTH;
 606
 607    /* Make sure MediaType is OK */
 608    if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
 609       return -1;
 610    }
 611
 612    if (!rctx.device->dev) {
 613       rctx.device->dev = init_dev(rctx.jcr, rctx.device);
 614    }
 615    if (!rctx.device->dev) {
 616       if (rctx.device->changer_res) {
 617         Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
 618            "     Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
 619              rctx.device->hdr.name, rctx.device_name);
 620       } else {
 621          Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
 622             "     Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
 623               rctx.device_name);
 624       }
 625       return -1;  /* no use waiting */
 626    }
 627    Dmsg2(100, "Try reserve %s jobid=%d\n", rctx.device->hdr.name,
 628          rctx.jcr->JobId);
 629    dcr = new_dcr(rctx.jcr, rctx.device->dev);
 630    if (!dcr) {
 631       BSOCK *dir = rctx.jcr->dir_bsock;
 632       bnet_fsend(dir, _("3926 Could not get dcr for device: %s\n"), rctx.device_name);
 633       Dmsg1(100, ">dird: %s", dir->msg);
 634       return -1;
 635    }
 636    bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
 637    bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
 638    bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
 639    bstrncpy(dcr->dev_name, rctx.device_name, name_len);
 640    if (rctx.store->append == SD_APPEND) {
 641       if (rctx.exact_match && !rctx.have_volume) {
 642          dcr->any_volume = true;
 643          if (dir_find_next_appendable_volume(dcr)) {
 644             Dmsg1(100, "Looking for Volume=%s\n", dcr->VolumeName);
 645             bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
 646             rctx.have_volume = true;
 647          } else {
 648             Dmsg0(100, "No next volume found\n");
 649             rctx.VolumeName[0] = 0;
 650         }
 651       }
 652       ok = reserve_device_for_append(dcr, rctx);
 653       if (ok) {
 654          rctx.jcr->dcr = dcr;
 655          Dmsg5(100, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
 656                dcr->dev->reserved_device,
 657                dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
 658       }
 659    } else {
 660       ok = reserve_device_for_read(dcr);
 661       if (ok) {
 662          rctx.jcr->read_dcr = dcr;
 663          Dmsg5(100, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
 664                dcr->dev->reserved_device,
 665                dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
 666       }
 667    }
 668    if (!ok) {
 669       free_dcr(dcr);
 670       Dmsg0(100, "Not OK.\n");
 671       return 0;
 672    }
 673    return 1;
 674 }
 675
 676 /*
 677  * We "reserve" the drive by setting the ST_READ bit. No one else
 678  *  should touch the drive until that is cleared.
 679  *  This allows the DIR to "reserve" the device before actually
 680  *  starting the job.
 681  */
 682 static bool reserve_device_for_read(DCR *dcr)
 683 {
 684    DEVICE *dev = dcr->dev;
 685    JCR *jcr = dcr->jcr;
 686    bool ok = false;
 687
 688    ASSERT(dcr);
 689
 690    P(dev->mutex);
 691
 692    if (is_device_unmounted(dev)) {
 693       Dmsg1(200, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
 694       Mmsg(jcr->errmsg, _("Device %s is BLOCKED due to user unmount.\n"),
 695            dev->print_name());
 696       goto bail_out;
 697    }
 698
 699    if (dev->is_busy()) {
 700       Dmsg4(200, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n", dev->print_name(),
 701          dev->state & ST_READ?1:0, dev->num_writers, dev->reserved_device);
 702       Mmsg1(jcr->errmsg, _("Device %s is busy.\n"),
 703             dev->print_name());
 704       goto bail_out;
 705    }
 706
 707    dev->clear_append();
 708    dev->set_read();
 709    ok = true;
 710
 711 bail_out:
 712    V(dev->mutex);
 713    return ok;
 714 }
 715
 716
 717 /*
 718  * We reserve the device for appending by incrementing the
 719  *  reserved_device. We do virtually all the same work that
 720  *  is done in acquire_device_for_append(), but we do
 721  *  not attempt to mount the device. This routine allows
 722  *  the DIR to reserve multiple devices before *really*
 723  *  starting the job. It also permits the SD to refuse
 724  *  certain devices (not up, ...).
 725  *
 726  * Note, in reserving a device, if the device is for the
 727  *  same pool and the same pool type, then it is acceptable.
 728  *  The Media Type has already been checked. If we are
 729  *  the first tor reserve the device, we put the pool
 730  *  name and pool type in the device record.
 731  */
 732 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
 733 {
 734    JCR *jcr = dcr->jcr;
 735    DEVICE *dev = dcr->dev;
 736    bool ok = false;
 737
 738    ASSERT(dcr);
 739
 740    P(dev->mutex);
 741
 742    if (dev->can_read()) {
 743       Mmsg1(jcr->errmsg, _("Device %s is busy reading.\n"), dev->print_name());
 744       Dmsg1(100, "%s", jcr->errmsg);
 745       goto bail_out;
 746    }
 747
 748    if (is_device_unmounted(dev)) {
 749       Mmsg(jcr->errmsg, _("Device %s is BLOCKED due to user unmount.\n"), dev->print_name());
 750       Dmsg1(100, "%s", jcr->errmsg);
 751       goto bail_out;
 752    }
 753
 754    Dmsg1(100, "reserve_append device is %s\n", dev->is_tape()?"tape":"disk");
 755
 756    if (can_reserve_drive(dcr, rctx) != 1) {
 757       Dmsg0(100, "can_reserve_drive!=1\n");
 758       goto bail_out;
 759    }
 760
 761    dev->reserved_device++;
 762    Dmsg3(100, "Inc reserve=%d dev=%s %p\n", dev->reserved_device,
 763       dev->print_name(), dev);
 764    dcr->reserved_device = true;
 765    ok = true;
 766
 767 bail_out:
 768    V(dev->mutex);
 769    return ok;
 770 }
 771
 772 /*
 773  * Returns: 1 if drive can be reserved
 774  *          0 if we should wait
 775  *         -1 on error
 776  */
 777 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
 778 {
 779    DEVICE *dev = dcr->dev;
 780    JCR *jcr = dcr->jcr;
 781
 782    /* If he wants a free drive, but this one is busy, no go */
 783    if (!rctx.PreferMountedVols && dev->is_busy()) {
 784       Dmsg1(100, "!prefMnt && busy. JobId=%d\n", jcr->JobId);
 785       return 0;
 786    }
 787    Dmsg3(100, "prefmnt=%d busy=%d res=%d\n", rctx.PreferMountedVols,
 788       dev->is_busy(), dev->reserved_device);
 789
 790    /* Check for prefer mounted volumes */
 791    if (rctx.PreferMountedVols && !dev->VolHdr.VolumeName[0] && dev->is_tape()) {
 792       Dmsg1(100, "want mounted -- no vol JobId=%d\n", jcr->JobId);
 793       return 0;                 /* No volume mounted */
 794    }
 795
 796    /* Check for exact Volume name match */
 797    if (rctx.exact_match && rctx.have_volume &&
 798        strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) != 0) {
 799       Dmsg2(100, "Not exact match have=%s want=%s\n",
 800             dev->VolHdr.VolumeName, rctx.VolumeName);
 801       return 0;
 802    }
 803
 804    /* Check for unused autochanger drive */
 805    if (rctx.available_autochanger && dev->num_writers == 0 &&
 806        dev->VolHdr.VolumeName[0] == 0) {
 807       /* Device is available but not yet reserved, reserve it for us */
 808       Dmsg2(100, "Res Unused autochanger %s JobId=%d.\n",
 809          dev->print_name(), jcr->JobId);
 810       bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
 811       bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
 812       return 1;                       /* reserve drive */
 813    }
 814
 815    /*
 816     * Handle the case that there are no writers
 817     */
 818    if (dev->num_writers == 0) {
 819       /* Now check if there are any reservations on the drive */
 820       if (dev->reserved_device) {
 821          /* Now check if we want the same Pool and pool type */
 822          if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
 823              strcmp(dev->pool_type, dcr->pool_type) == 0) {
 824             /* OK, compatible device */
 825             Dmsg2(100, "got dev: %s num_writers=0, reserved, pool matches JobId=%d\n",
 826                dev->print_name(), jcr->JobId);
 827             return 1;
 828          } else {
 829             /* Drive not suitable for us */
 830             Dmsg2(100, "busy: num_writers=0, reserved, pool=%s wanted=%s\n",
 831                dev->pool_name, dcr->pool_name);
 832             return 0;                 /* wait */
 833          }
 834       } else if (dev->can_append()) {
 835          /* Device in append mode, check if changing pool */
 836          if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
 837              strcmp(dev->pool_type, dcr->pool_type) == 0) {
 838             Dmsg2(100, "got dev: %s num_writers=0, can_append, pool matches. JobId=%d\n",
 839                dev->print_name(), jcr->JobId);
 840             /* OK, compatible device */
 841             return 1;
 842          } else {
 843             /* Changing pool, unload old tape if any in drive */
 844             Dmsg0(100, "got dev: num_writers=0, not reserved, pool change, unload changer\n");
 845             unload_autochanger(dcr, 0);
 846          }
 847       }
 848       /* Device is available but not yet reserved, reserve it for us */
 849       Dmsg2(100, "Dev avail reserved %s JobId=%d\n", dev->print_name(),
 850          jcr->JobId);
 851       bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
 852       bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
 853       return 1;                       /* reserve drive */
 854    }
 855
 856    /*
 857     * Check if the device is in append mode with writers (i.e.
 858     *  available if pool is the same).
 859     */
 860    if (dev->can_append() || dev->num_writers > 0) {
 861       /* Yes, now check if we want the same Pool and pool type */
 862       if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
 863           strcmp(dev->pool_type, dcr->pool_type) == 0) {
 864          Dmsg2(100, "got dev: %s num_writers>=0, can_append, pool matches. JobId=%d\n",
 865             dev->print_name(), jcr->JobId);
 866          /* OK, compatible device */
 867          return 1;
 868       } else {
 869          /* Drive not suitable for us */
 870          Dmsg2(100, "busy: num_writers>0, can_append, pool=%s wanted=%s\n",
 871             dev->pool_name, dcr->pool_name);
 872          return 0;                    /* wait */
 873       }
 874    } else {
 875       Pmsg0(000, _("Logic error!!!! Should not get here.\n"));
 876       Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
 877       return -1;                      /* error, should not get here */
 878    }
 879    Dmsg2(100, "No reserve %s JobId=%d\n", dev->print_name(), jcr->JobId);
 880    return 0;
 881 }