git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/next_vol.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2001-2008 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of 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  *
  30  *   Bacula Director -- next_vol -- handles finding the next
  31  *    volume for append.  Split out of catreq.c August MMIII
  32  *    catalog request from the Storage daemon.
  33
  34  *     Kern Sibbald, March MMI
  35  *
  36  *   Version $Id$
  37  */
  38
  39 #include "bacula.h"
  40 #include "dird.h"
  41
  42 /*
  43  *  Items needed:
  44  *   mr.PoolId must be set
  45  *   jcr->wstore
  46  *   jcr->db
  47  *   jcr->pool
  48  *   MEDIA_DBR mr with PoolId set
  49  *   create -- whether or not to create a new volume
  50  */
  51 int find_next_volume_for_append(JCR *jcr, MEDIA_DBR *mr, int index,
  52                                 bool create, bool prune)
  53 {
  54    int retry = 0;
  55    bool ok;
  56    bool InChanger;
  57    STORE *store = jcr->wstore;
  58
  59    bstrncpy(mr->MediaType, store->media_type, sizeof(mr->MediaType));
  60    Dmsg3(100, "find_next_vol_for_append: JobId=%u PoolId=%d, MediaType=%s\n",
  61          (uint32_t)jcr->JobId, (int)mr->PoolId, mr->MediaType);
  62    /*
  63     * If we are using an Autochanger, restrict Volume
  64     *   search to the Autochanger on the first pass
  65     */
  66    InChanger = store->autochanger;
  67    /*
  68     * Find the Next Volume for Append
  69     */
  70    db_lock(jcr->db);
  71    for ( ;; ) {
  72       bstrncpy(mr->VolStatus, "Append", sizeof(mr->VolStatus));  /* want only appendable volumes */
  73       /*
  74        *  1. Look for volume with "Append" status.
  75        */
  76       ok = db_find_next_volume(jcr, jcr->db, index, InChanger, mr);
  77
  78       if (!ok) {
  79          Dmsg4(050, "after find_next_vol ok=%d index=%d InChanger=%d Vstat=%s\n",
  80                ok, index, InChanger, mr->VolStatus);
  81          /*
  82           * 2. Try finding a recycled volume
  83           */
  84          ok = find_recycled_volume(jcr, InChanger, mr);
  85          Dmsg2(150, "find_recycled_volume ok=%d FW=%d\n", ok, mr->FirstWritten);
  86          if (!ok) {
  87             /*
  88              * 3. Try recycling any purged volume
  89              */
  90             ok = recycle_oldest_purged_volume(jcr, InChanger, mr);
  91             if (!ok) {
  92                /*
  93                 * 4. Try pruning Volumes
  94                 */
  95                if (prune) {
  96                   Dmsg0(150, "Call prune_volumes\n");
  97                   ok = prune_volumes(jcr, InChanger, mr);
  98                }
  99                if (!ok) {
 100                   ok = recycle_oldest_purged_volume(jcr, InChanger, mr);
 101                   if (!ok && create) {
 102                      Dmsg4(050, "after prune volumes_vol ok=%d index=%d InChanger=%d Vstat=%s\n",
 103                            ok, index, InChanger, mr->VolStatus);
 104                      /*
 105                       * 5. Try pulling a volume from the Scratch pool
 106                       */
 107                      ok = get_scratch_volume(jcr, InChanger, mr);
 108                      Dmsg4(050, "after get scratch volume ok=%d index=%d InChanger=%d Vstat=%s\n",
 109                            ok, index, InChanger, mr->VolStatus);
 110                   }
 111                   /*
 112                    * If we are using an Autochanger and have not found
 113                    * a volume, retry looking for any volume.
 114                    */
 115                   if (!ok && InChanger) {
 116                      InChanger = false;
 117                      continue;           /* retry again accepting any volume */
 118                   }
 119                }
 120             }
 121          }
 122
 123
 124          if (!ok && create) {
 125             /*
 126              * 6. Try "creating" a new Volume
 127              */
 128             ok = newVolume(jcr, mr);
 129          }
 130          /*
 131           *  Look at more drastic ways to find an Appendable Volume
 132           */
 133          if (!ok && (jcr->pool->purge_oldest_volume ||
 134                      jcr->pool->recycle_oldest_volume)) {
 135             Dmsg2(200, "No next volume found. PurgeOldest=%d\n RecyleOldest=%d",
 136                 jcr->pool->purge_oldest_volume, jcr->pool->recycle_oldest_volume);
 137             /* Find oldest volume to recycle */
 138             ok = db_find_next_volume(jcr, jcr->db, -1, InChanger, mr);
 139             Dmsg1(400, "Find oldest=%d\n", ok);
 140             if (ok && prune) {
 141                UAContext *ua;
 142                Dmsg0(400, "Try purge.\n");
 143                /*
 144                 * 7.  Try to purging oldest volume only if not UA calling us.
 145                 */
 146                ua = new_ua_context(jcr);
 147                if (jcr->pool->purge_oldest_volume && create) {
 148                   Jmsg(jcr, M_INFO, 0, _("Purging oldest volume \"%s\"\n"), mr->VolumeName);
 149                   ok = purge_jobs_from_volume(ua, mr);
 150                /*
 151                 * 8. or try recycling the oldest volume
 152                 */
 153                } else if (jcr->pool->recycle_oldest_volume) {
 154                   Jmsg(jcr, M_INFO, 0, _("Pruning oldest volume \"%s\"\n"), mr->VolumeName);
 155                   ok = prune_volume(ua, mr);
 156                }
 157                free_ua_context(ua);
 158                if (ok) {
 159                   ok = recycle_volume(jcr, mr);
 160                   Dmsg1(400, "Recycle after purge oldest=%d\n", ok);
 161                }
 162             }
 163          }
 164       }
 165       Dmsg2(100, "VolJobs=%d FirstWritten=%d\n", mr->VolJobs, mr->FirstWritten);
 166       if (ok) {
 167          /* If we can use the volume, check if it is expired */
 168          if (has_volume_expired(jcr, mr)) {
 169             if (retry++ < 200) {            /* sanity check */
 170                continue;                    /* try again from the top */
 171             } else {
 172                Jmsg(jcr, M_ERROR, 0, _(
 173 "We seem to be looping trying to find the next volume. I give up.\n"));
 174             }
 175          }
 176       }
 177       break;
 178    } /* end for loop */
 179    db_unlock(jcr->db);
 180    Dmsg1(150, "return ok=%d find_next_vol\n", ok);
 181    return ok;
 182 }
 183
 184 /*
 185  * Check if any time limits or use limits have expired
 186  *   if so, set the VolStatus appropriately.
 187  */
 188 bool has_volume_expired(JCR *jcr, MEDIA_DBR *mr)
 189 {
 190    bool expired = false;
 191    /*
 192     * Check limits and expirations if "Append" and it has been used
 193     * i.e. mr->VolJobs > 0
 194     *
 195     */
 196    if (strcmp(mr->VolStatus, "Append") == 0 && mr->VolJobs > 0) {
 197       /* First handle Max Volume Bytes */
 198       if ((mr->MaxVolBytes > 0 && mr->VolBytes >= mr->MaxVolBytes)) {
 199          Jmsg(jcr, M_INFO, 0, _("Max Volume bytes exceeded. "
 200              "Marking Volume \"%s\" as Full.\n"), mr->VolumeName);
 201          bstrncpy(mr->VolStatus, "Full", sizeof(mr->VolStatus));
 202          expired = true;
 203
 204       /* Now see if Volume should only be used once */
 205       } else if (mr->VolBytes > 0 && jcr->pool->use_volume_once) {
 206          Jmsg(jcr, M_INFO, 0, _("Volume used once. "
 207              "Marking Volume \"%s\" as Used.\n"), mr->VolumeName);
 208          bstrncpy(mr->VolStatus, "Used", sizeof(mr->VolStatus));
 209          expired = true;
 210
 211       /* Now see if Max Jobs written to volume */
 212       } else if (mr->MaxVolJobs > 0 && mr->MaxVolJobs <= mr->VolJobs) {
 213          Jmsg(jcr, M_INFO, 0, _("Max Volume jobs exceeded. "
 214              "Marking Volume \"%s\" as Used.\n"), mr->VolumeName);
 215          Dmsg3(100, "MaxVolJobs=%d JobId=%d Vol=%s\n", mr->MaxVolJobs,
 216                (uint32_t)jcr->JobId, mr->VolumeName);
 217          bstrncpy(mr->VolStatus, "Used", sizeof(mr->VolStatus));
 218          expired = true;
 219
 220       /* Now see if Max Files written to volume */
 221       } else if (mr->MaxVolFiles > 0 && mr->MaxVolFiles <= mr->VolFiles) {
 222          Jmsg(jcr, M_INFO, 0, _("Max Volume files exceeded. "
 223              "Marking Volume \"%s\" as Used.\n"), mr->VolumeName);
 224          bstrncpy(mr->VolStatus, "Used", sizeof(mr->VolStatus));
 225          expired = true;
 226
 227       /* Finally, check Use duration expiration */
 228       } else if (mr->VolUseDuration > 0) {
 229          utime_t now = time(NULL);
 230          /* See if Vol Use has expired */
 231          if (mr->VolUseDuration <= (now - mr->FirstWritten)) {
 232             Jmsg(jcr, M_INFO, 0, _("Max configured use duration exceeded. "
 233                "Marking Volume \"%s\" as Used.\n"), mr->VolumeName);
 234             bstrncpy(mr->VolStatus, "Used", sizeof(mr->VolStatus));
 235             expired = true;
 236          }
 237       }
 238    }
 239    if (expired) {
 240       /* Need to update media */
 241       if (!db_update_media_record(jcr, jcr->db, mr)) {
 242          Jmsg(jcr, M_ERROR, 0, _("Catalog error updating volume \"%s\". ERR=%s"),
 243               mr->VolumeName, db_strerror(jcr->db));
 244       }
 245    }
 246    return expired;
 247 }
 248
 249 /*
 250  * Try hard to recycle the current volume
 251  *
 252  *  Returns: on failure - reason = NULL
 253  *           on success - reason - pointer to reason
 254  */
 255 void check_if_volume_valid_or_recyclable(JCR *jcr, MEDIA_DBR *mr, const char **reason)
 256 {
 257    int ok;
 258
 259    *reason = NULL;
 260
 261    /*  Check if a duration or limit has expired */
 262    if (has_volume_expired(jcr, mr)) {
 263       *reason = _("volume has expired");
 264       /* Keep going because we may be able to recycle volume */
 265    }
 266
 267    /*
 268     * Now see if we can use the volume as is
 269     */
 270    if (strcmp(mr->VolStatus, "Append") == 0 ||
 271        strcmp(mr->VolStatus, "Recycle") == 0) {
 272       *reason = NULL;
 273       return;
 274    }
 275
 276    /*
 277     * Check if the Volume is already marked for recycling
 278     */
 279    if (strcmp(mr->VolStatus, "Purged") == 0) {
 280       if (recycle_volume(jcr, mr)) {
 281          Jmsg(jcr, M_INFO, 0, _("Recycled current volume \"%s\"\n"), mr->VolumeName);
 282          *reason = NULL;
 283          return;
 284       } else {
 285          /* In principle this shouldn't happen */
 286          *reason = _("and recycling of current volume failed");
 287          return;
 288       }
 289    }
 290
 291    /* At this point, the volume is not valid for writing */
 292    *reason = _("but should be Append, Purged or Recycle");
 293
 294    /*
 295     * What we're trying to do here is see if the current volume is
 296     * "recyclable" - ie. if we prune all expired jobs off it, is
 297     * it now possible to reuse it for the job that it is currently
 298     * needed for?
 299     */
 300    if ((mr->LastWritten + mr->VolRetention) < (utime_t)time(NULL)
 301          && mr->Recycle && jcr->pool->recycle_current_volume
 302          && (strcmp(mr->VolStatus, "Full") == 0 ||
 303             strcmp(mr->VolStatus, "Used") == 0)) {
 304       /*
 305        * Attempt prune of current volume to see if we can
 306        * recycle it for use.
 307        */
 308       UAContext *ua;
 309
 310       ua = new_ua_context(jcr);
 311       ok = prune_volume(ua, mr);
 312       free_ua_context(ua);
 313
 314       if (ok) {
 315          /* If fully purged, recycle current volume */
 316          if (recycle_volume(jcr, mr)) {
 317             Jmsg(jcr, M_INFO, 0, _("Recycled current volume \"%s\"\n"), mr->VolumeName);
 318             *reason = NULL;
 319          } else {
 320             *reason = _("but should be Append, Purged or Recycle (recycling of the "
 321                "current volume failed)");
 322          }
 323       } else {
 324          *reason = _("but should be Append, Purged or Recycle (cannot automatically "
 325             "recycle current volume, as it still contains unpruned data "
 326             "or the Volume Retention time has not expired.)");
 327       }
 328    }
 329 }
 330
 331 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 332
 333 bool get_scratch_volume(JCR *jcr, bool InChanger, MEDIA_DBR *mr)
 334 {
 335    MEDIA_DBR smr;                        /* for searching scratch pool */
 336    POOL_DBR spr, pr;
 337    bool ok = false;
 338    bool found = false;
 339
 340    /* Only one thread at a time can pull from the scratch pool */
 341    P(mutex);
 342    /*
 343     * Get Pool record for Scratch Pool
 344     */
 345    memset(&spr, 0, sizeof(spr));
 346    bstrncpy(spr.Name, "Scratch", sizeof(spr.Name));
 347    if (db_get_pool_record(jcr, jcr->db, &spr)) {
 348       memset(&smr, 0, sizeof(smr));
 349       smr.PoolId = spr.PoolId;
 350       if (InChanger) {
 351          smr.StorageId = mr->StorageId;  /* want only Scratch Volumes in changer */
 352       }
 353       bstrncpy(smr.VolStatus, "Append", sizeof(smr.VolStatus));  /* want only appendable volumes */
 354       bstrncpy(smr.MediaType, mr->MediaType, sizeof(smr.MediaType));
 355
 356       /*
 357        * If we do not find a valid Scratch volume, try
 358        *  recycling any existing purged volumes, then
 359        *  try to take the oldest volume.
 360        */
 361       if (db_find_next_volume(jcr, jcr->db, 1, InChanger, &smr)) {
 362          found = true;
 363
 364       } else if (find_recycled_volume(jcr, InChanger, &smr)) {
 365          found = true;
 366
 367       } else if (recycle_oldest_purged_volume(jcr, InChanger, &smr)) {
 368          found = true;
 369       }
 370
 371       if (found) {
 372          POOL_MEM query(PM_MESSAGE);
 373
 374          /*
 375           * Get pool record where the Scratch Volume will go to ensure
 376           * that we can add a Volume.
 377           */
 378          memset(&pr, 0, sizeof(pr));
 379          bstrncpy(pr.Name, jcr->pool->name(), sizeof(pr.Name));
 380
 381          if (!db_get_pool_record(jcr, jcr->db, &pr)) {
 382             Jmsg(jcr, M_WARNING, 0, _("Unable to get Pool record: ERR=%s"),
 383                  db_strerror(jcr->db));
 384             goto bail_out;
 385          }
 386
 387          /* Make sure there is room for another volume */
 388          if (pr.MaxVols > 0 && pr.NumVols >= pr.MaxVols) {
 389             Jmsg(jcr, M_WARNING, 0, _("Unable add Scratch Volume, Pool \"%s\" full MaxVols=%d\n"),
 390                  jcr->pool->name(), pr.MaxVols);
 391             goto bail_out;
 392          }
 393
 394          memcpy(mr, &smr, sizeof(MEDIA_DBR));
 395
 396          /* Set default parameters from current pool */
 397          set_pool_dbr_defaults_in_media_dbr(mr, &pr);
 398
 399          /*
 400           * set_pool_dbr_defaults_in_media_dbr set VolStatus to Append,
 401           *   we could have Recycled media, also, we retain the old
 402           *   RecyclePoolId.
 403           */
 404          bstrncpy(mr->VolStatus, smr.VolStatus, sizeof(smr.VolStatus));
 405          mr->RecyclePoolId = smr.RecyclePoolId;
 406
 407          if (!db_update_media_record(jcr, jcr->db, mr)) {
 408             Jmsg(jcr, M_WARNING, 0, _("Failed to move Scratch Volume. ERR=%s\n"),
 409                  db_strerror(jcr->db));
 410             goto bail_out;
 411          }
 412
 413          Jmsg(jcr, M_INFO, 0, _("Using Volume \"%s\" from 'Scratch' pool.\n"),
 414               mr->VolumeName);
 415
 416          ok = true;
 417       }
 418    }
 419 bail_out:
 420    V(mutex);
 421    return ok;
 422 }