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