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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2009 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 Kern Sibbald.
  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 const int dbglvl = 150;
  43
  44 static brwlock_t reservation_lock;
  45
  46 /* Forward referenced functions */
  47 static int can_reserve_drive(DCR *dcr, RCTX &rctx);
  48 static int reserve_device(RCTX &rctx);
  49 static bool reserve_device_for_read(DCR *dcr);
  50 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx);
  51 static bool use_storage_cmd(JCR *jcr);
  52 static void queue_reserve_message(JCR *jcr);
  53 static void pop_reserve_messages(JCR *jcr);
  54 //void switch_device(DCR *dcr, DEVICE *dev);
  55
  56 /* Requests from the Director daemon */
  57 static char use_storage[]  = "use storage=%127s media_type=%127s "
  58    "pool_name=%127s pool_type=%127s append=%d copy=%d stripe=%d\n";
  59 static char use_device[]  = "use device=%127s\n";
  60
  61 /* Responses sent to Director daemon */
  62 static char OK_device[] = "3000 OK use device device=%s\n";
  63 static char NO_device[] = "3924 Device \"%s\" not in SD Device resources.\n";
  64 static char BAD_use[]   = "3913 Bad use command: %s\n";
  65
  66 bool use_cmd(JCR *jcr)
  67 {
  68    /*
  69     * Get the device, media, and pool information
  70     */
  71    if (!use_storage_cmd(jcr)) {
  72       set_jcr_job_status(jcr, JS_ErrorTerminated);
  73       memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
  74       return false;
  75    }
  76    return true;
  77 }
  78
  79 /*
  80  * This allows a given thread to recursively call lock_reservations.
  81  *   It must, of course, call unlock_... the same number of times.
  82  */
  83 void init_reservations_lock()
  84 {
  85    int errstat;
  86    if ((errstat=rwl_init(&reservation_lock)) != 0) {
  87       berrno be;
  88       Emsg1(M_ABORT, 0, _("Unable to initialize reservation lock. ERR=%s\n"),
  89             be.bstrerror(errstat));
  90    }
  91
  92    init_vol_list_lock();
  93 }
  94
  95 void term_reservations_lock()
  96 {
  97    rwl_destroy(&reservation_lock);
  98    term_vol_list_lock();
  99 }
 100
 101 int reservations_lock_count = 0;
 102
 103 /* This applies to a drive and to Volumes */
 104 void _lock_reservations()
 105 {
 106    int errstat;
 107    reservations_lock_count++;
 108    if ((errstat=rwl_writelock(&reservation_lock)) != 0) {
 109       berrno be;
 110       Emsg2(M_ABORT, 0, "rwl_writelock failure. stat=%d: ERR=%s\n",
 111            errstat, be.bstrerror(errstat));
 112    }
 113 }
 114
 115 void _unlock_reservations()
 116 {
 117    int errstat;
 118    reservations_lock_count--;
 119    if ((errstat=rwl_writeunlock(&reservation_lock)) != 0) {
 120       berrno be;
 121       Emsg2(M_ABORT, 0, "rwl_writeunlock failure. stat=%d: ERR=%s\n",
 122            errstat, be.bstrerror(errstat));
 123    }
 124 }
 125
 126 void DCR::set_reserved()
 127 {
 128    m_reserved = true;
 129    Dmsg2(dbglvl, "Inc reserve=%d dev=%s\n", dev->num_reserved(), dev->print_name());
 130    dev->inc_reserved();
 131 }
 132
 133 void DCR::clear_reserved()
 134 {
 135    if (m_reserved) {
 136       m_reserved = false;
 137       dev->dec_reserved();
 138       Dmsg2(dbglvl, "Dec reserve=%d dev=%s\n", dev->num_reserved(), dev->print_name());
 139    }
 140 }
 141
 142 /*
 143  * Remove any reservation from a drive and tell the system
 144  *  that the volume is unused at least by us.
 145  */
 146 void DCR::unreserve_device()
 147 {
 148    dev->dlock();
 149    lock_volumes();
 150    if (is_reserved()) {
 151       clear_reserved();
 152       reserved_volume = false;
 153       /* If we set read mode in reserving, remove it */
 154       if (dev->can_read()) {
 155          dev->clear_read();
 156       }
 157       if (dev->num_writers < 0) {
 158          Jmsg1(jcr, M_ERROR, 0, _("Hey! num_writers=%d!!!!\n"), dev->num_writers);
 159          dev->num_writers = 0;
 160       }
 161       if (dev->num_reserved() == 0 && dev->num_writers == 0) {
 162          volume_unused(this);
 163       }
 164    }
 165    unlock_volumes();
 166    dev->dunlock();
 167 }
 168
 169 /*
 170  * We get the following type of information:
 171  *
 172  * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=1 copy=0 strip=0
 173  *  use device=zzz
 174  *  use device=aaa
 175  *  use device=bbb
 176  * use storage=xxx media_type=yyy pool_name=xxx pool_type=yyy append=0 copy=0 strip=0
 177  *  use device=bbb
 178  *
 179  */
 180 static bool use_storage_cmd(JCR *jcr)
 181 {
 182    POOL_MEM store_name, dev_name, media_type, pool_name, pool_type;
 183    BSOCK *dir = jcr->dir_bsock;
 184    int append;
 185    bool ok;
 186    int Copy, Stripe;
 187    DIRSTORE *store;
 188    RCTX rctx;
 189    alist *dirstore;
 190
 191    memset(&rctx, 0, sizeof(RCTX));
 192    rctx.jcr = jcr;
 193    /*
 194     * If there are multiple devices, the director sends us
 195     *   use_device for each device that it wants to use.
 196     */
 197    dirstore = New(alist(10, not_owned_by_alist));
 198    jcr->reserve_msgs = New(alist(10, not_owned_by_alist));
 199    do {
 200       Dmsg1(dbglvl, "<dird: %s", dir->msg);
 201       ok = sscanf(dir->msg, use_storage, store_name.c_str(),
 202                   media_type.c_str(), pool_name.c_str(),
 203                   pool_type.c_str(), &append, &Copy, &Stripe) == 7;
 204       if (!ok) {
 205          break;
 206       }
 207       if (append) {
 208          jcr->write_store = dirstore;
 209       } else {
 210          jcr->read_store = dirstore;
 211       }
 212       rctx.append = append;
 213       unbash_spaces(store_name);
 214       unbash_spaces(media_type);
 215       unbash_spaces(pool_name);
 216       unbash_spaces(pool_type);
 217       store = new DIRSTORE;
 218       dirstore->append(store);
 219       memset(store, 0, sizeof(DIRSTORE));
 220       store->device = New(alist(10));
 221       bstrncpy(store->name, store_name, sizeof(store->name));
 222       bstrncpy(store->media_type, media_type, sizeof(store->media_type));
 223       bstrncpy(store->pool_name, pool_name, sizeof(store->pool_name));
 224       bstrncpy(store->pool_type, pool_type, sizeof(store->pool_type));
 225       store->append = append;
 226
 227       /* Now get all devices */
 228       while (dir->recv() >= 0) {
 229          Dmsg1(dbglvl, "<dird device: %s", dir->msg);
 230          ok = sscanf(dir->msg, use_device, dev_name.c_str()) == 1;
 231          if (!ok) {
 232             break;
 233          }
 234          unbash_spaces(dev_name);
 235          store->device->append(bstrdup(dev_name.c_str()));
 236       }
 237    }  while (ok && dir->recv() >= 0);
 238
 239    /* Developer debug code */
 240    char *device_name;
 241    if (debug_level >= dbglvl) {
 242       foreach_alist(store, dirstore) {
 243          Dmsg5(dbglvl, "Storage=%s media_type=%s pool=%s pool_type=%s append=%d\n",
 244             store->name, store->media_type, store->pool_name,
 245             store->pool_type, store->append);
 246          foreach_alist(device_name, store->device) {
 247             Dmsg1(dbglvl, "     Device=%s\n", device_name);
 248          }
 249       }
 250    }
 251
 252    init_jcr_device_wait_timers(jcr);
 253    jcr->dcr = new_dcr(jcr, NULL, NULL);         /* get a dcr */
 254    if (!jcr->dcr) {
 255       BSOCK *dir = jcr->dir_bsock;
 256       dir->fsend(_("3939 Could not get dcr\n"));
 257       Dmsg1(dbglvl, ">dird: %s", dir->msg);
 258       ok = false;
 259    }
 260    /*
 261     * At this point, we have a list of all the Director's Storage
 262     *  resources indicated for this Job, which include Pool, PoolType,
 263     *  storage name, and Media type.
 264     * Then for each of the Storage resources, we have a list of
 265     *  device names that were given.
 266     *
 267     * Wiffle through them and find one that can do the backup.
 268     */
 269    if (ok) {
 270       int wait_for_device_retries = 0;
 271       int repeat = 0;
 272       bool fail = false;
 273       rctx.notify_dir = true;
 274
 275       lock_reservations();
 276       for ( ; !fail && !job_canceled(jcr); ) {
 277          pop_reserve_messages(jcr);
 278          rctx.suitable_device = false;
 279          rctx.have_volume = false;
 280          rctx.VolumeName[0] = 0;
 281          rctx.any_drive = false;
 282          if (!jcr->PreferMountedVols) {
 283             /*
 284              * Here we try to find a drive that is not used.
 285              * This will maximize the use of available drives.
 286              *
 287              */
 288             rctx.num_writers = 20000000;   /* start with impossible number */
 289             rctx.low_use_drive = NULL;
 290             rctx.PreferMountedVols = false;
 291             rctx.exact_match = false;
 292             rctx.autochanger_only = true;
 293             if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 294                break;
 295             }
 296             /* Look through all drives possibly for low_use drive */
 297             if (rctx.low_use_drive) {
 298                rctx.try_low_use_drive = true;
 299                if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 300                   break;
 301                }
 302                rctx.try_low_use_drive = false;
 303             }
 304             rctx.autochanger_only = false;
 305             if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 306                break;
 307             }
 308          }
 309          /*
 310           * Now we look for a drive that may or may not be in
 311           *  use.
 312           */
 313          /* Look for an exact Volume match all drives */
 314          rctx.PreferMountedVols = true;
 315          rctx.exact_match = true;
 316          rctx.autochanger_only = false;
 317          if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 318             break;
 319          }
 320          /* Look for any mounted drive */
 321          rctx.exact_match = false;
 322          if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 323             break;
 324          }
 325          /* Try any drive */
 326          rctx.any_drive = true;
 327          if ((ok = find_suitable_device_for_job(jcr, rctx))) {
 328             break;
 329          }
 330          /* Keep reservations locked *except* during wait_for_device() */
 331          unlock_reservations();
 332          /*
 333           * The idea of looping on repeat a few times it to ensure
 334           * that if there is some subtle timing problem between two
 335           * jobs, we will simply try again, and most likely succeed.
 336           * This can happen if one job reserves a drive or finishes using
 337           * a drive at the same time a second job wants it.
 338           */
 339          if (repeat++ > 1) {              /* try algorithm 3 times */
 340             bmicrosleep(30, 0);           /* wait a bit */
 341             Dmsg0(dbglvl, "repeat reserve algorithm\n");
 342          } else if (!rctx.suitable_device || !wait_for_device(jcr, wait_for_device_retries)) {
 343             Dmsg0(dbglvl, "Fail. !suitable_device || !wait_for_device\n");
 344             fail = true;
 345          }
 346          lock_reservations();
 347          dir->signal(BNET_HEARTBEAT);  /* Inform Dir that we are alive */
 348       }
 349       unlock_reservations();
 350       if (!ok) {
 351          /*
 352           * If we get here, there are no suitable devices available, which
 353           *  means nothing configured.  If a device is suitable but busy
 354           *  with another Volume, we will not come here.
 355           */
 356          unbash_spaces(dir->msg);
 357          pm_strcpy(jcr->errmsg, dir->msg);
 358          Jmsg(jcr, M_FATAL, 0, _("Device reservation failed for JobId=%d: %s\n"),
 359               jcr->JobId, jcr->errmsg);
 360          dir->fsend(NO_device, dev_name.c_str());
 361
 362          Dmsg1(dbglvl, ">dird: %s", dir->msg);
 363       }
 364    } else {
 365       unbash_spaces(dir->msg);
 366       pm_strcpy(jcr->errmsg, dir->msg);
 367       Jmsg(jcr, M_FATAL, 0, _("Failed command: %s\n"), jcr->errmsg);
 368       dir->fsend(BAD_use, jcr->errmsg);
 369       Dmsg1(dbglvl, ">dird: %s", dir->msg);
 370    }
 371
 372    release_reserve_messages(jcr);
 373    return ok;
 374 }
 375
 376
 377 /*
 378  * Walk through the autochanger resources and check if
 379  *  the volume is in one of them.
 380  *
 381  * Returns:  true  if volume is in device
 382  *           false otherwise
 383  */
 384 static bool is_vol_in_autochanger(RCTX &rctx, VOLRES *vol)
 385 {
 386    AUTOCHANGER *changer = vol->dev->device->changer_res;
 387
 388    /* Find resource, and make sure we were able to open it */
 389    if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
 390       Dmsg1(dbglvl, "Found changer device %s\n", vol->dev->device->hdr.name);
 391       return true;
 392    }
 393    Dmsg1(dbglvl, "Incorrect changer device %s\n", changer->hdr.name);
 394    return false;
 395 }
 396
 397 /*
 398  * Search for a device suitable for this job.
 399  * Note, this routine sets sets rctx.suitable_device if any
 400  *   device exists within the SD.  The device may not be actually
 401  *   useable.
 402  * It also returns if it finds a useable device.
 403  */
 404 bool find_suitable_device_for_job(JCR *jcr, RCTX &rctx)
 405 {
 406    bool ok = false;
 407    DIRSTORE *store;
 408    char *device_name;
 409    alist *dirstore;
 410    DCR *dcr = jcr->dcr;
 411
 412    if (rctx.append) {
 413       dirstore = jcr->write_store;
 414    } else {
 415       dirstore = jcr->read_store;
 416    }
 417    Dmsg5(dbglvl, "Start find_suit_dev PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
 418          rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
 419          rctx.autochanger_only, rctx.any_drive);
 420
 421    /*
 422     * If the appropriate conditions of this if are met, namely that
 423     *  we are appending and the user wants mounted drive (or we
 424     *  force try a mounted drive because they are all busy), we
 425     *  start by looking at all the Volumes in the volume list.
 426     */
 427    if (!is_vol_list_empty() && rctx.append && rctx.PreferMountedVols) {
 428       dlist *temp_vol_list;
 429       VOLRES *vol = NULL;
 430       temp_vol_list = dup_vol_list(jcr);
 431
 432       /* Look through reserved volumes for one we can use */
 433       Dmsg0(dbglvl, "look for vol in vol list\n");
 434       foreach_dlist(vol, temp_vol_list) {
 435          if (!vol->dev) {
 436             Dmsg1(dbglvl, "vol=%s no dev\n", vol->vol_name);
 437             continue;
 438          }
 439          /* Check with Director if this Volume is OK */
 440          bstrncpy(dcr->VolumeName, vol->vol_name, sizeof(dcr->VolumeName));
 441          if (!dir_get_volume_info(dcr, GET_VOL_INFO_FOR_WRITE)) {
 442             continue;
 443          }
 444
 445          Dmsg1(dbglvl, "vol=%s OK for this job\n", vol->vol_name);
 446          foreach_alist(store, dirstore) {
 447             int stat;
 448             rctx.store = store;
 449             foreach_alist(device_name, store->device) {
 450                /* Found a device, try to use it */
 451                rctx.device_name = device_name;
 452                rctx.device = vol->dev->device;
 453
 454                if (vol->dev->is_autochanger()) {
 455                   Dmsg1(dbglvl, "vol=%s is in changer\n", vol->vol_name);
 456                   if (!is_vol_in_autochanger(rctx, vol)) {
 457                      continue;
 458                   }
 459                } else if (strcmp(device_name, vol->dev->device->hdr.name) != 0) {
 460                   Dmsg2(dbglvl, "device=%s not suitable want %s\n",
 461                         vol->dev->device->hdr.name, device_name);
 462                   continue;
 463                }
 464
 465                bstrncpy(rctx.VolumeName, vol->vol_name, sizeof(rctx.VolumeName));
 466                rctx.have_volume = true;
 467                /* Try reserving this device and volume */
 468                Dmsg2(dbglvl, "try vol=%s on device=%s\n", rctx.VolumeName, device_name);
 469                stat = reserve_device(rctx);
 470                if (stat == 1) {             /* found available device */
 471                   Dmsg1(dbglvl, "Suitable device found=%s\n", device_name);
 472                   ok = true;
 473                   break;
 474                } else if (stat == 0) {      /* device busy */
 475                   Dmsg1(dbglvl, "Suitable device=%s, busy: not use\n", device_name);
 476                } else {
 477                   /* otherwise error */
 478                   Dmsg0(dbglvl, "No suitable device found.\n");
 479                }
 480                rctx.have_volume = false;
 481                rctx.VolumeName[0] = 0;
 482             }
 483             if (ok) {
 484                break;
 485             }
 486          }
 487          if (ok) {
 488             break;
 489          }
 490       } /* end for loop over reserved volumes */
 491
 492       Dmsg0(dbglvl, "lock volumes\n");
 493       free_temp_vol_list(temp_vol_list);
 494    }
 495    if (ok) {
 496       Dmsg1(dbglvl, "OK dev found. Vol=%s from in-use vols list\n", rctx.VolumeName);
 497       return true;
 498    }
 499
 500    /*
 501     * No reserved volume we can use, so now search for an available device.
 502     *
 503     * For each storage device that the user specified, we
 504     *  search and see if there is a resource for that device.
 505     */
 506    foreach_alist(store, dirstore) {
 507       rctx.store = store;
 508       foreach_alist(device_name, store->device) {
 509          int stat;
 510          rctx.device_name = device_name;
 511          stat = search_res_for_device(rctx);
 512          if (stat == 1) {             /* found available device */
 513             Dmsg1(dbglvl, "available device found=%s\n", device_name);
 514             ok = true;
 515             break;
 516          } else if (stat == 0) {      /* device busy */
 517             Dmsg1(dbglvl, "No usable device=%s, busy: not use\n", device_name);
 518          } else {
 519             /* otherwise error */
 520             Dmsg0(dbglvl, "No usable device found.\n");
 521          }
 522       }
 523       if (ok) {
 524          break;
 525       }
 526    }
 527    if (ok) {
 528       Dmsg1(dbglvl, "OK dev found. Vol=%s\n", rctx.VolumeName);
 529    } else {
 530       Dmsg0(dbglvl, "Leave find_suit_dev: no dev found.\n");
 531    }
 532    return ok;
 533 }
 534
 535 /*
 536  * Search for a particular storage device with particular storage
 537  *  characteristics (MediaType).
 538  */
 539 int search_res_for_device(RCTX &rctx)
 540 {
 541    AUTOCHANGER *changer;
 542    int stat;
 543
 544    Dmsg1(dbglvl, "search res for %s\n", rctx.device_name);
 545    /* Look through Autochangers first */
 546    foreach_res(changer, R_AUTOCHANGER) {
 547       Dmsg1(dbglvl, "Try match changer res=%s\n", changer->hdr.name);
 548       /* Find resource, and make sure we were able to open it */
 549       if (strcmp(rctx.device_name, changer->hdr.name) == 0) {
 550          /* Try each device in this AutoChanger */
 551          foreach_alist(rctx.device, changer->device) {
 552             Dmsg1(dbglvl, "Try changer device %s\n", rctx.device->hdr.name);
 553             if (!rctx.device->autoselect) {
 554                Dmsg1(100, "Device %s not autoselect skipped.\n",
 555                rctx.device->hdr.name);
 556                continue;              /* device is not available */
 557             }
 558             stat = reserve_device(rctx);
 559             if (stat != 1) {             /* try another device */
 560                continue;
 561             }
 562             /* Debug code */
 563             if (rctx.store->append == SD_APPEND) {
 564                Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
 565                   rctx.device->hdr.name, rctx.jcr->dcr->dev->num_reserved());
 566             } else {
 567                Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
 568                   rctx.device->hdr.name, rctx.jcr->read_dcr->dev->num_reserved());
 569             }
 570             return stat;
 571          }
 572       }
 573    }
 574
 575    /* Now if requested look through regular devices */
 576    if (!rctx.autochanger_only) {
 577       foreach_res(rctx.device, R_DEVICE) {
 578          Dmsg1(dbglvl, "Try match res=%s\n", rctx.device->hdr.name);
 579          /* Find resource, and make sure we were able to open it */
 580          if (strcmp(rctx.device_name, rctx.device->hdr.name) == 0) {
 581             stat = reserve_device(rctx);
 582             if (stat != 1) {             /* try another device */
 583                continue;
 584             }
 585             /* Debug code */
 586             if (rctx.store->append == SD_APPEND) {
 587                Dmsg2(dbglvl, "Device %s reserved=%d for append.\n",
 588                   rctx.device->hdr.name, rctx.jcr->dcr->dev->num_reserved());
 589             } else {
 590                Dmsg2(dbglvl, "Device %s reserved=%d for read.\n",
 591                   rctx.device->hdr.name, rctx.jcr->read_dcr->dev->num_reserved());
 592             }
 593             return stat;
 594          }
 595       }
 596    }
 597    return -1;                    /* nothing found */
 598 }
 599
 600 /*
 601  *  Try to reserve a specific device.
 602  *
 603  *  Returns: 1 -- OK, have DCR
 604  *           0 -- must wait
 605  *          -1 -- fatal error
 606  */
 607 static int reserve_device(RCTX &rctx)
 608 {
 609    bool ok;
 610    DCR *dcr;
 611    const int name_len = MAX_NAME_LENGTH;
 612
 613    /* Make sure MediaType is OK */
 614    Dmsg2(dbglvl, "chk MediaType device=%s request=%s\n",
 615          rctx.device->media_type, rctx.store->media_type);
 616    if (strcmp(rctx.device->media_type, rctx.store->media_type) != 0) {
 617       return -1;
 618    }
 619
 620    /* Make sure device exists -- i.e. we can stat() it */
 621    if (!rctx.device->dev) {
 622       rctx.device->dev = init_dev(rctx.jcr, rctx.device);
 623    }
 624    if (!rctx.device->dev) {
 625       if (rctx.device->changer_res) {
 626         Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
 627            "     Device \"%s\" in changer \"%s\" requested by DIR could not be opened or does not exist.\n"),
 628              rctx.device->hdr.name, rctx.device_name);
 629       } else {
 630          Jmsg(rctx.jcr, M_WARNING, 0, _("\n"
 631             "     Device \"%s\" requested by DIR could not be opened or does not exist.\n"),
 632               rctx.device_name);
 633       }
 634       return -1;  /* no use waiting */
 635    }
 636
 637    rctx.suitable_device = true;
 638    Dmsg1(dbglvl, "try reserve %s\n", rctx.device->hdr.name);
 639    if (rctx.store->append) {
 640       dcr = new_dcr(rctx.jcr, rctx.jcr->dcr, rctx.device->dev);
 641    } else {
 642       dcr = new_dcr(rctx.jcr, rctx.jcr->read_dcr, rctx.device->dev);
 643    }
 644    if (!dcr) {
 645       BSOCK *dir = rctx.jcr->dir_bsock;
 646       dir->fsend(_("3926 Could not get dcr for device: %s\n"), rctx.device_name);
 647       Dmsg1(dbglvl, ">dird: %s", dir->msg);
 648       return -1;
 649    }
 650    bstrncpy(dcr->pool_name, rctx.store->pool_name, name_len);
 651    bstrncpy(dcr->pool_type, rctx.store->pool_type, name_len);
 652    bstrncpy(dcr->media_type, rctx.store->media_type, name_len);
 653    bstrncpy(dcr->dev_name, rctx.device_name, name_len);
 654    if (rctx.store->append == SD_APPEND) {
 655       Dmsg2(dbglvl, "call reserve for append: have_vol=%d vol=%s\n", rctx.have_volume, rctx.VolumeName);
 656       ok = reserve_device_for_append(dcr, rctx);
 657       if (!ok) {
 658          goto bail_out;
 659       }
 660
 661       rctx.jcr->dcr = dcr;
 662       Dmsg5(dbglvl, "Reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
 663                dcr->dev->num_reserved(),
 664                dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
 665       Dmsg3(dbglvl, "Vol=%s num_writers=%d, have_vol=%d\n",
 666          rctx.VolumeName, dcr->dev->num_writers, rctx.have_volume);
 667       if (rctx.have_volume) {
 668          Dmsg0(dbglvl, "Call reserve_volume\n");
 669          if (reserve_volume(dcr, rctx.VolumeName)) {
 670             Dmsg1(dbglvl, "Reserved vol=%s\n", rctx.VolumeName);
 671          } else {
 672             Dmsg1(dbglvl, "Could not reserve vol=%s\n", rctx.VolumeName);
 673             goto bail_out;
 674          }
 675       } else {
 676          dcr->any_volume = true;
 677          Dmsg0(dbglvl, "no vol, call find_next_appendable_vol.\n");
 678          if (dir_find_next_appendable_volume(dcr)) {
 679             bstrncpy(rctx.VolumeName, dcr->VolumeName, sizeof(rctx.VolumeName));
 680             rctx.have_volume = true;
 681             Dmsg1(dbglvl, "looking for Volume=%s\n", rctx.VolumeName);
 682          } else {
 683             Dmsg0(dbglvl, "No next volume found\n");
 684             rctx.have_volume = false;
 685             rctx.VolumeName[0] = 0;
 686             /*
 687              * If there is at least one volume that is valid and in use,
 688              *   but we get here, check if we are running with prefers
 689              *   non-mounted drives.  In that case, we have selected a
 690              *   non-used drive and our one and only volume is mounted
 691              *   elsewhere, so we bail out and retry using that drive.
 692              */
 693             if (dcr->found_in_use() && !rctx.PreferMountedVols) {
 694                rctx.PreferMountedVols = true;
 695                if (dcr->VolumeName[0]) {
 696                   dcr->unreserve_device();
 697                }
 698                goto bail_out;
 699             }
 700             /*
 701              * Note. Under some circumstances, the Director can hand us
 702              *  a Volume name that is not the same as the one on the current
 703              *  drive, and in that case, the call above to find the next
 704              *  volume will fail because in attempting to reserve the Volume
 705              *  the code will realize that we already have a tape mounted,
 706              *  and it will fail.  This *should* only happen if there are
 707              *  writers, thus the following test.  In that case, we simply
 708              *  bail out, and continue waiting, rather than plunging on
 709              *  and hoping that the operator can resolve the problem.
 710              */
 711             if (dcr->dev->num_writers != 0) {
 712                if (dcr->VolumeName[0]) {
 713                   dcr->unreserve_device();
 714                }
 715                goto bail_out;
 716             }
 717          }
 718       }
 719    } else {
 720       ok = reserve_device_for_read(dcr);
 721       if (ok) {
 722          rctx.jcr->read_dcr = dcr;
 723          Dmsg5(dbglvl, "Read reserved=%d dev_name=%s mediatype=%s pool=%s ok=%d\n",
 724                dcr->dev->num_reserved(),
 725                dcr->dev_name, dcr->media_type, dcr->pool_name, ok);
 726       }
 727    }
 728    if (!ok) {
 729       goto bail_out;
 730    }
 731
 732    if (rctx.notify_dir) {
 733       POOL_MEM dev_name;
 734       BSOCK *dir = rctx.jcr->dir_bsock;
 735       pm_strcpy(dev_name, rctx.device->hdr.name);
 736       bash_spaces(dev_name);
 737       ok = dir->fsend(OK_device, dev_name.c_str());  /* Return real device name */
 738       Dmsg1(dbglvl, ">dird: %s", dir->msg);
 739    } else {
 740       ok = true;
 741    }
 742    return ok ? 1 : -1;
 743
 744 bail_out:
 745    rctx.have_volume = false;
 746    rctx.VolumeName[0] = 0;
 747    Dmsg0(dbglvl, "Not OK.\n");
 748    return 0;
 749 }
 750
 751 /*
 752  * We "reserve" the drive by setting the ST_READ bit. No one else
 753  *  should touch the drive until that is cleared.
 754  *  This allows the DIR to "reserve" the device before actually
 755  *  starting the job.
 756  */
 757 static bool reserve_device_for_read(DCR *dcr)
 758 {
 759    DEVICE *dev = dcr->dev;
 760    JCR *jcr = dcr->jcr;
 761    bool ok = false;
 762
 763    ASSERT(dcr);
 764    if (job_canceled(jcr)) {
 765       return false;
 766    }
 767
 768    dev->dlock();
 769
 770    if (dev->is_device_unmounted()) {
 771       Dmsg1(dbglvl, "Device %s is BLOCKED due to user unmount.\n", dev->print_name());
 772       Mmsg(jcr->errmsg, _("3601 JobId=%u device %s is BLOCKED due to user unmount.\n"),
 773            jcr->JobId, dev->print_name());
 774       queue_reserve_message(jcr);
 775       goto bail_out;
 776    }
 777
 778    if (dev->is_busy()) {
 779       Dmsg4(dbglvl, "Device %s is busy ST_READ=%d num_writers=%d reserved=%d.\n",
 780          dev->print_name(),
 781          dev->state & ST_READ?1:0, dev->num_writers, dev->num_reserved());
 782       Mmsg(jcr->errmsg, _("3602 JobId=%u device %s is busy (already reading/writing).\n"),
 783             jcr->JobId, dev->print_name());
 784       queue_reserve_message(jcr);
 785       goto bail_out;
 786    }
 787
 788    dev->clear_append();
 789    dev->set_read();
 790    ok = true;
 791    dcr->set_reserved();
 792
 793 bail_out:
 794    dev->dunlock();
 795    return ok;
 796 }
 797
 798
 799 /*
 800  * We reserve the device for appending by incrementing
 801  *  num_reserved(). We do virtually all the same work that
 802  *  is done in acquire_device_for_append(), but we do
 803  *  not attempt to mount the device. This routine allows
 804  *  the DIR to reserve multiple devices before *really*
 805  *  starting the job. It also permits the SD to refuse
 806  *  certain devices (not up, ...).
 807  *
 808  * Note, in reserving a device, if the device is for the
 809  *  same pool and the same pool type, then it is acceptable.
 810  *  The Media Type has already been checked. If we are
 811  *  the first tor reserve the device, we put the pool
 812  *  name and pool type in the device record.
 813  */
 814 static bool reserve_device_for_append(DCR *dcr, RCTX &rctx)
 815 {
 816    JCR *jcr = dcr->jcr;
 817    DEVICE *dev = dcr->dev;
 818    bool ok = false;
 819
 820    ASSERT(dcr);
 821    if (job_canceled(jcr)) {
 822       return false;
 823    }
 824
 825    dev->dlock();
 826
 827    /* If device is being read, we cannot write it */
 828    if (dev->can_read()) {
 829       Mmsg(jcr->errmsg, _("3603 JobId=%u device %s is busy reading.\n"),
 830          jcr->JobId, dev->print_name());
 831       Dmsg1(dbglvl, "%s", jcr->errmsg);
 832       queue_reserve_message(jcr);
 833       goto bail_out;
 834    }
 835
 836    /* If device is unmounted, we are out of luck */
 837    if (dev->is_device_unmounted()) {
 838       Mmsg(jcr->errmsg, _("3604 JobId=%u device %s is BLOCKED due to user unmount.\n"),
 839          jcr->JobId, dev->print_name());
 840       Dmsg1(dbglvl, "%s", jcr->errmsg);
 841       queue_reserve_message(jcr);
 842       goto bail_out;
 843    }
 844
 845    Dmsg1(dbglvl, "reserve_append device is %s\n", dev->print_name());
 846
 847    /* Now do detailed tests ... */
 848    if (can_reserve_drive(dcr, rctx) != 1) {
 849       Dmsg0(dbglvl, "can_reserve_drive!=1\n");
 850       goto bail_out;
 851    }
 852
 853    dcr->set_reserved();
 854    ok = true;
 855
 856 bail_out:
 857    dev->dunlock();
 858    return ok;
 859 }
 860
 861 static int is_pool_ok(DCR *dcr)
 862 {
 863    DEVICE *dev = dcr->dev;
 864    JCR *jcr = dcr->jcr;
 865
 866    /* Now check if we want the same Pool and pool type */
 867    if (strcmp(dev->pool_name, dcr->pool_name) == 0 &&
 868        strcmp(dev->pool_type, dcr->pool_type) == 0) {
 869       /* OK, compatible device */
 870       Dmsg1(dbglvl, "OK dev: %s num_writers=0, reserved, pool matches\n", dev->print_name());
 871       return 1;
 872    } else {
 873       /* Drive Pool not suitable for us */
 874       Mmsg(jcr->errmsg, _(
 875 "3608 JobId=%u wants Pool=\"%s\" but have Pool=\"%s\" nreserve=%d on drive %s.\n"),
 876             (uint32_t)jcr->JobId, dcr->pool_name, dev->pool_name,
 877             dev->num_reserved(), dev->print_name());
 878       queue_reserve_message(jcr);
 879       Dmsg2(dbglvl, "failed: busy num_writers=0, reserved, pool=%s wanted=%s\n",
 880          dev->pool_name, dcr->pool_name);
 881    }
 882    return 0;
 883 }
 884
 885 static bool is_max_jobs_ok(DCR *dcr)
 886 {
 887    DEVICE *dev = dcr->dev;
 888    JCR *jcr = dcr->jcr;
 889
 890    Dmsg5(dbglvl, "MaxJobs=%d Jobs=%d reserves=%d Status=%s Vol=%s\n",
 891          dcr->VolCatInfo.VolCatMaxJobs,
 892          dcr->VolCatInfo.VolCatJobs, dev->num_reserved(),
 893          dcr->VolCatInfo.VolCatStatus,
 894          dcr->VolumeName);
 895    /* Limit max concurrent jobs on this drive */
 896    if (dev->max_concurrent_jobs > 0 && dev->max_concurrent_jobs <=
 897               (uint32_t)(dev->num_writers + dev->num_reserved())) {
 898       /* Max Concurrent Jobs depassed or already reserved */
 899       Mmsg(jcr->errmsg, _("3609 JobId=%u Max concurrent jobs exceeded on drive %s.\n"),
 900             (uint32_t)jcr->JobId, dev->print_name());
 901       queue_reserve_message(jcr);
 902       Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
 903       return false;
 904    }
 905    if (strcmp(dcr->VolCatInfo.VolCatStatus, "Recycle") == 0) {
 906       return true;
 907    }
 908    if (dcr->VolCatInfo.VolCatMaxJobs > 0 && dcr->VolCatInfo.VolCatMaxJobs <=
 909         (dcr->VolCatInfo.VolCatJobs + dev->num_reserved())) {
 910       /* Max Job Vols depassed or already reserved */
 911       Mmsg(jcr->errmsg, _("3610 JobId=%u Volume max jobs exceeded on drive %s.\n"),
 912             (uint32_t)jcr->JobId, dev->print_name());
 913       queue_reserve_message(jcr);
 914       Dmsg1(dbglvl, "reserve dev failed: %s", jcr->errmsg);
 915       return false;                /* wait */
 916    }
 917    return true;
 918 }
 919
 920 /*
 921  * Returns: 1 if drive can be reserved
 922  *          0 if we should wait
 923  *         -1 on error or impossibility
 924  */
 925 static int can_reserve_drive(DCR *dcr, RCTX &rctx)
 926 {
 927    DEVICE *dev = dcr->dev;
 928    JCR *jcr = dcr->jcr;
 929
 930    Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
 931          rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
 932          rctx.autochanger_only, rctx.any_drive);
 933
 934    /* Check for max jobs on this Volume */
 935    if (!is_max_jobs_ok(dcr)) {
 936       return 0;
 937    }
 938
 939    /* setting any_drive overrides PreferMountedVols flag */
 940    if (!rctx.any_drive) {
 941       /*
 942        * When PreferMountedVols is set, we keep track of the
 943        *  drive in use that has the least number of writers, then if
 944        *  no unmounted drive is found, we try that drive. This
 945        *  helps spread the load to the least used drives.
 946        */
 947       if (rctx.try_low_use_drive && dev == rctx.low_use_drive) {
 948          Dmsg2(dbglvl, "OK dev=%s == low_drive=%s.\n",
 949             dev->print_name(), rctx.low_use_drive->print_name());
 950          return 1;
 951       }
 952       /* If he wants a free drive, but this one is busy, no go */
 953       if (!rctx.PreferMountedVols && dev->is_busy()) {
 954          /* Save least used drive */
 955          if ((dev->num_writers + dev->num_reserved()) < rctx.num_writers) {
 956             rctx.num_writers = dev->num_writers + dev->num_reserved();
 957             rctx.low_use_drive = dev;
 958             Dmsg2(dbglvl, "set low use drive=%s num_writers=%d\n",
 959                dev->print_name(), rctx.num_writers);
 960          } else {
 961             Dmsg1(dbglvl, "not low use num_writers=%d\n", dev->num_writers+dev->num_reserved());
 962          }
 963          Dmsg0(dbglvl, "failed: !prefMnt && busy.\n");
 964          Mmsg(jcr->errmsg, _("3605 JobId=%u wants free drive but device %s is busy.\n"),
 965             jcr->JobId, dev->print_name());
 966          queue_reserve_message(jcr);
 967          return 0;
 968       }
 969
 970       /* Check for prefer mounted volumes */
 971       if (rctx.PreferMountedVols && !dev->vol && dev->is_tape()) {
 972          Mmsg(jcr->errmsg, _("3606 JobId=%u prefers mounted drives, but drive %s has no Volume.\n"),
 973             jcr->JobId, dev->print_name());
 974          queue_reserve_message(jcr);
 975          Dmsg0(dbglvl, "failed: want mounted -- no vol\n");
 976          return 0;                 /* No volume mounted */
 977       }
 978
 979       /* Check for exact Volume name match */
 980       /* ***FIXME*** for Disk, we can accept any volume that goes with this
 981        *    drive.
 982        */
 983       if (rctx.exact_match && rctx.have_volume) {
 984          bool ok;
 985          Dmsg5(dbglvl, "PrefMnt=%d exact=%d suitable=%d chgronly=%d any=%d\n",
 986                rctx.PreferMountedVols, rctx.exact_match, rctx.suitable_device,
 987                rctx.autochanger_only, rctx.any_drive);
 988          Dmsg4(dbglvl, "have_vol=%d have=%s resvol=%s want=%s\n",
 989                   rctx.have_volume, dev->VolHdr.VolumeName,
 990                   dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
 991          ok = strcmp(dev->VolHdr.VolumeName, rctx.VolumeName) == 0 ||
 992                  (dev->vol && strcmp(dev->vol->vol_name, rctx.VolumeName) == 0);
 993          if (!ok) {
 994             Mmsg(jcr->errmsg, _("3607 JobId=%u wants Vol=\"%s\" drive has Vol=\"%s\" on drive %s.\n"),
 995                jcr->JobId, rctx.VolumeName, dev->VolHdr.VolumeName,
 996                dev->print_name());
 997             queue_reserve_message(jcr);
 998             Dmsg3(dbglvl, "not OK: dev have=%s resvol=%s want=%s\n",
 999                   dev->VolHdr.VolumeName, dev->vol?dev->vol->vol_name:"*none*", rctx.VolumeName);
1000             return 0;
1001          }
1002          if (!dcr->can_i_use_volume()) {
1003             return 0;              /* fail if volume on another drive */
1004          }
1005       }
1006    }
1007
1008    /* Check for unused autochanger drive */
1009    if (rctx.autochanger_only && !dev->is_busy() &&
1010        dev->VolHdr.VolumeName[0] == 0) {
1011       /* Device is available but not yet reserved, reserve it for us */
1012       Dmsg1(dbglvl, "OK Res Unused autochanger %s.\n", dev->print_name());
1013       bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1014       bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1015       return 1;                       /* reserve drive */
1016    }
1017
1018    /*
1019     * Handle the case that there are no writers
1020     */
1021    if (dev->num_writers == 0) {
1022       /* Now check if there are any reservations on the drive */
1023       if (dev->num_reserved()) {
1024          return is_pool_ok(dcr);
1025       } else if (dev->can_append()) {
1026          if (is_pool_ok(dcr)) {
1027             return 1;
1028          } else {
1029             /* Changing pool, unload old tape if any in drive */
1030             Dmsg0(dbglvl, "OK dev: num_writers=0, not reserved, pool change, unload changer\n");
1031             /* ***FIXME*** use set_unload() */
1032             unload_autochanger(dcr, -1);
1033          }
1034       }
1035       /* Device is available but not yet reserved, reserve it for us */
1036       Dmsg1(dbglvl, "OK Dev avail reserved %s\n", dev->print_name());
1037       bstrncpy(dev->pool_name, dcr->pool_name, sizeof(dev->pool_name));
1038       bstrncpy(dev->pool_type, dcr->pool_type, sizeof(dev->pool_type));
1039       return 1;                       /* reserve drive */
1040    }
1041
1042    /*
1043     * Check if the device is in append mode with writers (i.e.
1044     *  available if pool is the same).
1045     */
1046    if (dev->can_append() || dev->num_writers > 0) {
1047       return is_pool_ok(dcr);
1048    } else {
1049       Pmsg1(000, _("Logic error!!!! JobId=%u Should not get here.\n"), (int)jcr->JobId);
1050       Mmsg(jcr->errmsg, _("3910 JobId=%u Logic error!!!! drive %s Should not get here.\n"),
1051             jcr->JobId, dev->print_name());
1052       queue_reserve_message(jcr);
1053       Jmsg0(jcr, M_FATAL, 0, _("Logic error!!!! Should not get here.\n"));
1054       return -1;                      /* error, should not get here */
1055    }
1056    Mmsg(jcr->errmsg, _("3911 JobId=%u failed reserve drive %s.\n"),
1057          jcr->JobId, dev->print_name());
1058    queue_reserve_message(jcr);
1059    Dmsg1(dbglvl, "failed: No reserve %s\n", dev->print_name());
1060    return 0;
1061 }
1062
1063
1064
1065
1066 /*
1067  * Queue a reservation error or failure message for this jcr
1068  */
1069 static void queue_reserve_message(JCR *jcr)
1070 {
1071    int i;
1072    alist *msgs;
1073    char *msg;
1074
1075    jcr->lock();
1076
1077    msgs = jcr->reserve_msgs;
1078    if (!msgs) {
1079       goto bail_out;
1080    }
1081    /*
1082     * Look for duplicate message.  If found, do
1083     * not insert
1084     */
1085    for (i=msgs->size()-1; i >= 0; i--) {
1086       msg = (char *)msgs->get(i);
1087       if (!msg) {
1088          goto bail_out;
1089       }
1090       /* Comparison based on 4 digit message number */
1091       if (strncmp(msg, jcr->errmsg, 4) == 0) {
1092          goto bail_out;
1093       }
1094    }
1095    /* Message unique, so insert it */
1096    jcr->reserve_msgs->push(bstrdup(jcr->errmsg));
1097
1098 bail_out:
1099    jcr->unlock();
1100 }
1101
1102 /*
1103  * Send any reservation messages queued for this jcr
1104  */
1105 void send_drive_reserve_messages(JCR *jcr, void sendit(const char *msg, int len, void *sarg), void *arg)
1106 {
1107    int i;
1108    alist *msgs;
1109    char *msg;
1110
1111    jcr->lock();
1112    msgs = jcr->reserve_msgs;
1113    if (!msgs || msgs->size() == 0) {
1114       goto bail_out;
1115    }
1116    for (i=msgs->size()-1; i >= 0; i--) {
1117       msg = (char *)msgs->get(i);
1118       if (msg) {
1119          sendit("   ", 3, arg);
1120          sendit(msg, strlen(msg), arg);
1121       } else {
1122          break;
1123       }
1124    }
1125
1126 bail_out:
1127    jcr->unlock();
1128 }
1129
1130 /*
1131  * Pop and release any reservations messages
1132  */
1133 static void pop_reserve_messages(JCR *jcr)
1134 {
1135    alist *msgs;
1136    char *msg;
1137
1138    jcr->lock();
1139    msgs = jcr->reserve_msgs;
1140    if (!msgs) {
1141       goto bail_out;
1142    }
1143    while ((msg = (char *)msgs->pop())) {
1144       free(msg);
1145    }
1146 bail_out:
1147    jcr->unlock();
1148 }
1149
1150 /*
1151  * Also called from acquire.c
1152  */
1153 void release_reserve_messages(JCR *jcr)
1154 {
1155    pop_reserve_messages(jcr);
1156    jcr->lock();
1157    if (!jcr->reserve_msgs) {
1158       goto bail_out;
1159    }
1160    delete jcr->reserve_msgs;
1161    jcr->reserve_msgs = NULL;
1162
1163 bail_out:
1164    jcr->unlock();
1165 }