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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2002-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 -- Bootstrap Record routines.
  31  *
  32  *      BSR (bootstrap record) handling routines split from
  33  *        ua_restore.c July MMIII
  34  *
  35  *     Kern Sibbald, July MMII
  36  *
  37  *   Version $Id$
  38  */
  39
  40 #include "bacula.h"
  41 #include "dird.h"
  42
  43 /* Forward referenced functions */
  44 static uint32_t write_bsr(UAContext *ua, RESTORE_CTX &rx, FILE *fd);
  45
  46 /*
  47  * Create new FileIndex entry for BSR
  48  */
  49 RBSR_FINDEX *new_findex()
  50 {
  51    RBSR_FINDEX *fi = (RBSR_FINDEX *)bmalloc(sizeof(RBSR_FINDEX));
  52    memset(fi, 0, sizeof(RBSR_FINDEX));
  53    return fi;
  54 }
  55
  56 /* Free all BSR FileIndex entries */
  57 static void free_findex(RBSR_FINDEX *fi)
  58 {
  59    RBSR_FINDEX *next;
  60    for ( ; fi; fi=next) {
  61       next = fi->next;
  62       free(fi);
  63    }
  64 }
  65
  66 /*
  67  * Get storage device name from Storage resource
  68  */
  69 static bool get_storage_device(char *device, char *storage)
  70 {
  71    STORE *store;
  72    if (storage[0] == 0) {
  73       return false;
  74    }
  75    store = (STORE *)GetResWithName(R_STORAGE, storage);
  76    if (!store) {
  77       return false;
  78    }
  79    DEVICE *dev = (DEVICE *)(store->device->first());
  80    if (!dev) {
  81       return false;
  82    }
  83    bstrncpy(device, dev->hdr.name, MAX_NAME_LENGTH);
  84    return true;
  85 }
  86
  87 /*
  88  * Our data structures were not designed completely
  89  *  correctly, so the file indexes cover the full
  90  *  range regardless of volume. The FirstIndex and LastIndex
  91  *  passed in here are for the current volume, so when
  92  *  writing out the fi, constrain them to those values.
  93  *
  94  * We are called here once for each JobMedia record
  95  *  for each Volume.
  96  */
  97 static uint32_t write_findex(RBSR_FINDEX *fi,
  98               int32_t FirstIndex, int32_t LastIndex, FILE *fd)
  99 {
 100    uint32_t count = 0;
 101    for ( ; fi; fi=fi->next) {
 102       int32_t findex, findex2;
 103       if ((fi->findex >= FirstIndex && fi->findex <= LastIndex) ||
 104           (fi->findex2 >= FirstIndex && fi->findex2 <= LastIndex) ||
 105           (fi->findex < FirstIndex && fi->findex2 > LastIndex)) {
 106          findex = fi->findex < FirstIndex ? FirstIndex : fi->findex;
 107          findex2 = fi->findex2 > LastIndex ? LastIndex : fi->findex2;
 108          if (findex == findex2) {
 109             fprintf(fd, "FileIndex=%d\n", findex);
 110             count++;
 111          } else {
 112             fprintf(fd, "FileIndex=%d-%d\n", findex, findex2);
 113             count += findex2 - findex + 1;
 114          }
 115       }
 116    }
 117    return count;
 118 }
 119
 120 /*
 121  * Find out if Volume defined with FirstIndex and LastIndex
 122  *   falls within the range of selected files in the bsr.
 123  */
 124 static bool is_volume_selected(RBSR_FINDEX *fi,
 125               int32_t FirstIndex, int32_t LastIndex)
 126 {
 127    for ( ; fi; fi=fi->next) {
 128       if ((fi->findex >= FirstIndex && fi->findex <= LastIndex) ||
 129           (fi->findex2 >= FirstIndex && fi->findex2 <= LastIndex) ||
 130           (fi->findex < FirstIndex && fi->findex2 > LastIndex)) {
 131          return true;
 132       }
 133    }
 134    return false;
 135 }
 136
 137
 138 /* Create a new bootstrap record */
 139 RBSR *new_bsr()
 140 {
 141    RBSR *bsr = (RBSR *)bmalloc(sizeof(RBSR));
 142    memset(bsr, 0, sizeof(RBSR));
 143    return bsr;
 144 }
 145
 146 /* Free the entire BSR */
 147 void free_bsr(RBSR *bsr)
 148 {
 149    RBSR *next;
 150    for ( ; bsr; bsr=next) {
 151       free_findex(bsr->fi);
 152       if (bsr->VolParams) {
 153          free(bsr->VolParams);
 154       }
 155       next = bsr->next;
 156       free(bsr);
 157    }
 158 }
 159
 160 /*
 161  * Complete the BSR by filling in the VolumeName and
 162  *  VolSessionId and VolSessionTime using the JobId
 163  */
 164 bool complete_bsr(UAContext *ua, RBSR *bsr)
 165 {
 166    for ( ; bsr; bsr=bsr->next) {
 167       JOB_DBR jr;
 168       memset(&jr, 0, sizeof(jr));
 169       jr.JobId = bsr->JobId;
 170       if (!db_get_job_record(ua->jcr, ua->db, &jr)) {
 171          ua->error_msg(_("Unable to get Job record. ERR=%s\n"), db_strerror(ua->db));
 172          return false;
 173       }
 174       bsr->VolSessionId = jr.VolSessionId;
 175       bsr->VolSessionTime = jr.VolSessionTime;
 176       if ((bsr->VolCount=db_get_job_volume_parameters(ua->jcr, ua->db, bsr->JobId,
 177            &(bsr->VolParams))) == 0) {
 178          ua->error_msg(_("Unable to get Job Volume Parameters. ERR=%s\n"), db_strerror(ua->db));
 179          if (bsr->VolParams) {
 180             free(bsr->VolParams);
 181             bsr->VolParams = NULL;
 182          }
 183          return false;
 184       }
 185    }
 186    return true;
 187 }
 188
 189 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 190 static uint32_t uniq = 0;
 191
 192 static void make_unique_restore_filename(UAContext *ua, POOL_MEM &fname)
 193 {
 194    JCR *jcr = ua->jcr;
 195    int i = find_arg_with_value(ua, "bootstrap");
 196    if (i >= 0) {
 197       Mmsg(fname, "%s", ua->argv[i]);
 198       jcr->unlink_bsr = false;
 199    } else {
 200       P(mutex);
 201       uniq++;
 202       V(mutex);
 203       Mmsg(fname, "%s/%s.restore.%u.bsr", working_directory, my_name, uniq);
 204       jcr->unlink_bsr = true;
 205    }
 206    if (jcr->RestoreBootstrap) {
 207       free(jcr->RestoreBootstrap);
 208    }
 209    jcr->RestoreBootstrap = bstrdup(fname.c_str());
 210 }
 211
 212 /*
 213  * Write the bootstrap records to file
 214  */
 215 uint32_t write_bsr_file(UAContext *ua, RESTORE_CTX &rx)
 216 {
 217    FILE *fd;
 218    POOL_MEM fname(PM_MESSAGE);
 219    uint32_t count = 0;;
 220    bool err;
 221
 222    make_unique_restore_filename(ua, fname);
 223    fd = fopen(fname.c_str(), "w+b");
 224    if (!fd) {
 225       berrno be;
 226       ua->error_msg(_("Unable to create bootstrap file %s. ERR=%s\n"),
 227          fname.c_str(), be.bstrerror());
 228       goto bail_out;
 229    }
 230    /* Write them to file */
 231    count = write_bsr(ua, rx, fd);
 232    err = ferror(fd);
 233    fclose(fd);
 234    if (count == 0) {
 235       ua->info_msg(_("No files found to read. No bootstrap file written.\n"));
 236       goto bail_out;
 237    }
 238    if (err) {
 239       ua->error_msg(_("Error writing bsr file.\n"));
 240       count = 0;
 241       goto bail_out;
 242    }
 243
 244    ua->send_msg(_("Bootstrap records written to %s\n"), fname.c_str());
 245
 246    if (debug_level >= 10) {
 247       print_bsr(ua, rx);
 248    }
 249
 250 bail_out:
 251    return count;
 252 }
 253
 254 void display_bsr_info(UAContext *ua, RESTORE_CTX &rx)
 255 {
 256    char *p;
 257    POOL_MEM volmsg(PM_MESSAGE);
 258    JobId_t JobId;
 259    char Device[MAX_NAME_LENGTH];
 260    RBSR *bsr;
 261
 262    /* Tell the user what he will need to mount */
 263    ua->send_msg("\n");
 264    ua->send_msg(_("The job will require the following\n"
 265                   "   Volume(s)                 Storage(s)                SD Device(s)\n"
 266                   "===========================================================================\n"));
 267    /* Create Unique list of Volumes using prompt list */
 268    start_prompt(ua, "");
 269    if (*rx.JobIds == 0) {
 270       /* Print Volumes in any order */
 271       for (bsr=rx.bsr; bsr; bsr=bsr->next) {
 272          for (int i=0; i < bsr->VolCount; i++) {
 273             if (bsr->VolParams[i].VolumeName[0]) {
 274                if (!get_storage_device(Device, bsr->VolParams[i].Storage)) {
 275                   Device[0] = 0;
 276                }
 277                Mmsg(volmsg, "%-25.25s %-25.25s %-25.25s",
 278                     bsr->VolParams[i].VolumeName,
 279                     bsr->VolParams[i].Storage, Device);
 280                add_prompt(ua, volmsg.c_str());
 281             }
 282          }
 283       }
 284    } else {
 285       /* Ensure that the volumes are printed in JobId order */
 286       for (p=rx.JobIds; get_next_jobid_from_list(&p, &JobId) > 0; ) {
 287          for (bsr=rx.bsr; bsr; bsr=bsr->next) {
 288             if (JobId != bsr->JobId) {
 289                continue;
 290             }
 291             for (int i=0; i < bsr->VolCount; i++) {
 292                if (bsr->VolParams[i].VolumeName[0]) {
 293                   if (!get_storage_device(Device, bsr->VolParams[i].Storage)) {
 294                      Device[0] = 0;
 295                   }
 296                   Mmsg(volmsg, "%-25.25s %-25.25s %-25.25s",
 297                        bsr->VolParams[i].VolumeName,
 298                        bsr->VolParams[i].Storage, Device);
 299                   add_prompt(ua, volmsg.c_str());
 300                }
 301             }
 302          }
 303       }
 304    }
 305    for (int i=0; i < ua->num_prompts; i++) {
 306       ua->send_msg("   %s\n", ua->prompt[i]);
 307       free(ua->prompt[i]);
 308    }
 309    if (ua->num_prompts == 0) {
 310       ua->send_msg(_("No Volumes found to restore.\n"));
 311    }
 312    ua->num_prompts = 0;
 313    ua->send_msg("\n");
 314
 315    return;
 316 }
 317
 318 /*
 319  * Here we actually write out the details of the bsr file.
 320  *  Note, there is one bsr for each JobId, but the bsr may
 321  *  have multiple volumes, which have been entered in the
 322  *  order they were written.
 323  * The bsrs must be written out in the order the JobIds
 324  *  are found in the jobid list.
 325  */
 326 static uint32_t write_bsr(UAContext *ua, RESTORE_CTX &rx, FILE *fd)
 327 {
 328    char ed1[50], ed2[50];
 329    uint32_t count = 0;
 330    uint32_t total_count = 0;
 331    uint32_t LastIndex = 0;
 332    bool first = true;
 333    char *p;
 334    JobId_t JobId;
 335    char device[MAX_NAME_LENGTH];
 336    RBSR *bsr;
 337    if (*rx.JobIds == 0) {
 338       for (bsr=rx.bsr; bsr; bsr=bsr->next) {
 339          /*
 340           * For a given volume, loop over all the JobMedia records.
 341           *   VolCount is the number of JobMedia records.
 342           */
 343          for (int i=0; i < bsr->VolCount; i++) {
 344             if (!is_volume_selected(bsr->fi, bsr->VolParams[i].FirstIndex,
 345                  bsr->VolParams[i].LastIndex)) {
 346                bsr->VolParams[i].VolumeName[0] = 0;  /* zap VolumeName */
 347                continue;
 348             }
 349             if (!rx.store) {
 350                find_storage_resource(ua, rx, bsr->VolParams[i].Storage,
 351                                              bsr->VolParams[i].MediaType);
 352             }
 353             fprintf(fd, "Volume=\"%s\"\n", bsr->VolParams[i].VolumeName);
 354             fprintf(fd, "MediaType=\"%s\"\n", bsr->VolParams[i].MediaType);
 355             if (bsr->fileregex) {
 356                fprintf(fd, "FileRegex=%s\n", bsr->fileregex);
 357             }
 358             if (get_storage_device(device, bsr->VolParams[i].Storage)) {
 359                fprintf(fd, "Device=\"%s\"\n", device);
 360             }
 361             if (bsr->VolParams[i].Slot > 0) {
 362                fprintf(fd, "Slot=%d\n", bsr->VolParams[i].Slot);
 363             }
 364             fprintf(fd, "VolSessionId=%u\n", bsr->VolSessionId);
 365             fprintf(fd, "VolSessionTime=%u\n", bsr->VolSessionTime);
 366             fprintf(fd, "VolAddr=%s-%s\n", edit_uint64(bsr->VolParams[i].StartAddr, ed1),
 367                     edit_uint64(bsr->VolParams[i].EndAddr, ed2));
 368    //       Dmsg2(100, "bsr VolParam FI=%u LI=%u\n",
 369    //          bsr->VolParams[i].FirstIndex, bsr->VolParams[i].LastIndex);
 370
 371             count = write_findex(bsr->fi, bsr->VolParams[i].FirstIndex,
 372                                  bsr->VolParams[i].LastIndex, fd);
 373             if (count) {
 374                fprintf(fd, "Count=%u\n", count);
 375             }
 376             total_count += count;
 377             /* If the same file is present on two tapes or in two files
 378              *   on a tape, it is a continuation, and should not be treated
 379              *   twice in the totals.
 380              */
 381             if (!first && LastIndex == bsr->VolParams[i].FirstIndex) {
 382                total_count--;
 383             }
 384             first = false;
 385             LastIndex = bsr->VolParams[i].LastIndex;
 386          }
 387       }
 388       return total_count;
 389    }
 390    for (p=rx.JobIds; get_next_jobid_from_list(&p, &JobId) > 0; ) {
 391       for (bsr=rx.bsr; bsr; bsr=bsr->next) {
 392          if (JobId != bsr->JobId) {
 393             continue;
 394          }
 395          /*
 396           * For a given volume, loop over all the JobMedia records.
 397           *   VolCount is the number of JobMedia records.
 398           */
 399          for (int i=0; i < bsr->VolCount; i++) {
 400             if (!is_volume_selected(bsr->fi, bsr->VolParams[i].FirstIndex,
 401                  bsr->VolParams[i].LastIndex)) {
 402                bsr->VolParams[i].VolumeName[0] = 0;  /* zap VolumeName */
 403                continue;
 404             }
 405             if (!rx.store) {
 406                find_storage_resource(ua, rx, bsr->VolParams[i].Storage,
 407                                              bsr->VolParams[i].MediaType);
 408             }
 409             fprintf(fd, "Volume=\"%s\"\n", bsr->VolParams[i].VolumeName);
 410             fprintf(fd, "MediaType=\"%s\"\n", bsr->VolParams[i].MediaType);
 411             if (bsr->fileregex) {
 412                fprintf(fd, "FileRegex=%s\n", bsr->fileregex);
 413             }
 414             if (get_storage_device(device, bsr->VolParams[i].Storage)) {
 415                fprintf(fd, "Device=\"%s\"\n", device);
 416             }
 417             if (bsr->VolParams[i].Slot > 0) {
 418                fprintf(fd, "Slot=%d\n", bsr->VolParams[i].Slot);
 419             }
 420             fprintf(fd, "VolSessionId=%u\n", bsr->VolSessionId);
 421             fprintf(fd, "VolSessionTime=%u\n", bsr->VolSessionTime);
 422             fprintf(fd, "VolAddr=%s-%s\n", edit_uint64(bsr->VolParams[i].StartAddr, ed1),
 423                     edit_uint64(bsr->VolParams[i].EndAddr, ed2));
 424    //       Dmsg2(100, "bsr VolParam FI=%u LI=%u\n",
 425    //          bsr->VolParams[i].FirstIndex, bsr->VolParams[i].LastIndex);
 426
 427             count = write_findex(bsr->fi, bsr->VolParams[i].FirstIndex,
 428                                  bsr->VolParams[i].LastIndex, fd);
 429             if (count) {
 430                fprintf(fd, "Count=%u\n", count);
 431             }
 432             total_count += count;
 433             /* If the same file is present on two tapes or in two files
 434              *   on a tape, it is a continuation, and should not be treated
 435              *   twice in the totals.
 436              */
 437             if (!first && LastIndex == bsr->VolParams[i].FirstIndex) {
 438                total_count--;
 439             }
 440             first = false;
 441             LastIndex = bsr->VolParams[i].LastIndex;
 442          }
 443       }
 444    }
 445    return total_count;
 446 }
 447
 448 void print_bsr(UAContext *ua, RESTORE_CTX &rx)
 449 {
 450    write_bsr(ua, rx, stdout);
 451 }
 452
 453
 454
 455
 456 /*
 457  * Add a FileIndex to the list of BootStrap records.
 458  *  Here we are only dealing with JobId's and the FileIndexes
 459  *  associated with those JobIds.
 460  * We expect that JobId, FileIndex are sorted ascending.
 461  */
 462 void add_findex(RBSR *bsr, uint32_t JobId, int32_t findex)
 463 {
 464    RBSR *nbsr;
 465    RBSR_FINDEX *fi, *lfi;
 466
 467    if (findex == 0) {
 468       return;                         /* probably a dummy directory */
 469    }
 470
 471    if (bsr->fi == NULL) {             /* if no FI add one */
 472       /* This is the first FileIndex item in the chain */
 473       bsr->fi = new_findex();
 474       bsr->JobId = JobId;
 475       bsr->fi->findex = findex;
 476       bsr->fi->findex2 = findex;
 477       return;
 478    }
 479    /* Walk down list of bsrs until we find the JobId */
 480    if (bsr->JobId != JobId) {
 481       for (nbsr=bsr->next; nbsr; nbsr=nbsr->next) {
 482          if (nbsr->JobId == JobId) {
 483             bsr = nbsr;
 484             break;
 485          }
 486       }
 487
 488       if (!nbsr) {                    /* Must add new JobId */
 489          /* Add new JobId at end of chain */
 490          for (nbsr=bsr; nbsr->next; nbsr=nbsr->next)
 491             {  }
 492          nbsr->next = new_bsr();
 493          nbsr->next->JobId = JobId;
 494          nbsr->next->fi = new_findex();
 495          nbsr->next->fi->findex = findex;
 496          nbsr->next->fi->findex2 = findex;
 497          return;
 498       }
 499    }
 500
 501    /*
 502     * At this point, bsr points to bsr containing this JobId,
 503     *  and we are sure that there is at least one fi record.
 504     */
 505    lfi = fi = bsr->fi;
 506    /* Check if this findex is smaller than first item */
 507    if (findex < fi->findex) {
 508       if ((findex+1) == fi->findex) {
 509          fi->findex = findex;         /* extend down */
 510          return;
 511       }
 512       fi = new_findex();              /* yes, insert before first item */
 513       fi->findex = findex;
 514       fi->findex2 = findex;
 515       fi->next = lfi;
 516       bsr->fi = fi;
 517       return;
 518    }
 519    /* Walk down fi chain and find where to insert insert new FileIndex */
 520    for ( ; fi; fi=fi->next) {
 521       if (findex == (fi->findex2 + 1)) {  /* extend up */
 522          RBSR_FINDEX *nfi;
 523          fi->findex2 = findex;
 524          /*
 525           * If the following record contains one higher, merge its
 526           *   file index by extending it up.
 527           */
 528          if (fi->next && ((findex+1) == fi->next->findex)) {
 529             nfi = fi->next;
 530             fi->findex2 = nfi->findex2;
 531             fi->next = nfi->next;
 532             free(nfi);
 533          }
 534          return;
 535       }
 536       if (findex < fi->findex) {      /* add before */
 537          if ((findex+1) == fi->findex) {
 538             fi->findex = findex;
 539             return;
 540          }
 541          break;
 542       }
 543       lfi = fi;
 544    }
 545    /* Add to last place found */
 546    fi = new_findex();
 547    fi->findex = findex;
 548    fi->findex2 = findex;
 549    fi->next = lfi->next;
 550    lfi->next = fi;
 551    return;
 552 }
 553
 554 /*
 555  * Add all possible  FileIndexes to the list of BootStrap records.
 556  *  Here we are only dealing with JobId's and the FileIndexes
 557  *  associated with those JobIds.
 558  */
 559 void add_findex_all(RBSR *bsr, uint32_t JobId)
 560 {
 561    RBSR *nbsr;
 562    RBSR_FINDEX *fi;
 563
 564    if (bsr->fi == NULL) {             /* if no FI add one */
 565       /* This is the first FileIndex item in the chain */
 566       bsr->fi = new_findex();
 567       bsr->JobId = JobId;
 568       bsr->fi->findex = 1;
 569       bsr->fi->findex2 = INT32_MAX;
 570       return;
 571    }
 572    /* Walk down list of bsrs until we find the JobId */
 573    if (bsr->JobId != JobId) {
 574       for (nbsr=bsr->next; nbsr; nbsr=nbsr->next) {
 575          if (nbsr->JobId == JobId) {
 576             bsr = nbsr;
 577             break;
 578          }
 579       }
 580
 581       if (!nbsr) {                    /* Must add new JobId */
 582          /* Add new JobId at end of chain */
 583          for (nbsr=bsr; nbsr->next; nbsr=nbsr->next)
 584             {  }
 585          nbsr->next = new_bsr();
 586          nbsr->next->JobId = JobId;
 587          nbsr->next->fi = new_findex();
 588          nbsr->next->fi->findex = 1;
 589          nbsr->next->fi->findex2 = INT32_MAX;
 590          return;
 591       }
 592    }
 593
 594    /*
 595     * At this point, bsr points to bsr containing this JobId,
 596     *  and we are sure that there is at least one fi record.
 597     */
 598    fi = bsr->fi;
 599    fi->findex = 1;
 600    fi->findex2 = INT32_MAX;
 601    return;
 602 }