X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fmatch_bsr.c;h=350de85a8415afca9d820e69b94fe8456173c2fc;hb=36b40d5c7f3ff90565ab73ac75f0dc4f6660ff37;hp=7e3a0e1668e7953a93463e32e5a0037156634f45;hpb=146093ef6187606ee79d4a5a42e93b03e5a518ce;p=bacula%2Fbacula

diff --git a/bacula/src/stored/match_bsr.c b/bacula/src/stored/match_bsr.c
old mode 100755
new mode 100644
index 7e3a0e1668..350de85a84
--- a/bacula/src/stored/match_bsr.c
+++ b/bacula/src/stored/match_bsr.c
@@ -1,22 +1,14 @@
-/*
- *   Match Bootstrap Records (used for restores) against
- *     Volume Records
- *
- *     Kern Sibbald, June MMII
- *
- *   Version $Id$
- */
 /*
    Bacula® - The Network Backup Solution
 
-   Copyright (C) 2002-2006 Free Software Foundation Europe e.V.
+   Copyright (C) 2002-2007 Free Software Foundation Europe e.V.
 
    The main author of Bacula is Kern Sibbald, with contributions from
    many others, a complete list can be found in the file AUTHORS.
    This program is Free Software; you can redistribute it and/or
    modify it under the terms of version two of the GNU General Public
-   License as published by the Free Software Foundation plus additions
-   that are listed in the file LICENSE.
+   License as published by the Free Software Foundation and included
+   in the file LICENSE.
 
    This program is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -28,12 +20,37 @@
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 
-   Bacula® is a registered trademark of John Walker.
+   Bacula® is a registered trademark of Kern Sibbald.
    The licensor of Bacula is the Free Software Foundation Europe
    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
    Switzerland, email:ftf@fsfeurope.org.
 */
+/*
+ *   Match Bootstrap Records (used for restores) against
+ *     Volume Records
+ *
+ *     Kern Sibbald, June MMII
+ *
+ *   Version $Id$
+ */
 
+/*
+ * ***FIXME***
+ * find_smallest_volfile needs to be fixed to only look at items that
+ *   are not marked as done.  Otherwise, it can find a bsr
+ *   that has already been consumed, and this will cause the
+ *   bsr to be used, thus we may seek back and re-read the
+ *   same records, causing an error.  This deficiency must
+ *   be fixed.  For the moment, it has been kludged in 
+ *   read_record.c to avoid seeking back if find_next_bsr
+ *   returns a bsr pointing to a smaller address (file/block).
+ *
+ * Also for efficiency, once a bsr is done, it really should be
+ *   delinked from the bsr chain.  This will avoid the above 
+ *   problem and make traversal of the bsr chain more efficient.
+ *
+ *   To be done ...
+ */
 
 #include "bacula.h"
 #include "stored.h"
@@ -43,7 +60,7 @@
 #include "lib/fnmatch.h"
 #endif
 
-const int dbglevel = 10;
+const int dbglevel = 500;
 
 /* Forward references */
 static int match_volume(BSR *bsr, BSR_VOLUME *volume, VOLUME_LABEL *volrec, bool done);
@@ -174,18 +191,20 @@ BSR *find_next_bsr(BSR *root_bsr, DEVICE *dev)
 {
    BSR *bsr;
    BSR *found_bsr = NULL;
-   bool no_file_seek = !dev->is_tape();
-#ifdef FILE_SEEK
-   no_file_seek = false;
-#endif
 
-   if (!root_bsr || !root_bsr->use_positioning ||
-       !root_bsr->reposition || no_file_seek) {
+   /* Do tape/disk seeking only if CAP_POSITIONBLOCKS is on */
+   if (!root_bsr) {
+      Dmsg0(dbglevel, "NULL root bsr pointer passed to find_next_bsr.\n");
+      return NULL;
+   }
+   if (!root_bsr->use_positioning ||
+       !root_bsr->reposition || !dev->has_cap(CAP_POSITIONBLOCKS)) {
       Dmsg2(dbglevel, "No nxt_bsr use_pos=%d repos=%d\n", root_bsr->use_positioning, root_bsr->reposition);
       return NULL;
    }
    Dmsg2(dbglevel, "use_pos=%d repos=%d\n", root_bsr->use_positioning, root_bsr->reposition);
    root_bsr->mount_next_volume = false;
+   /* Walk through all bsrs to find the next one to use => smallest file,block */
    for (bsr=root_bsr; bsr; bsr=bsr->next) {
       if (bsr->done || !match_volume(bsr, bsr->volume, &dev->VolHdr, 1)) {
          continue;
@@ -207,6 +226,17 @@ BSR *find_next_bsr(BSR *root_bsr, DEVICE *dev)
    return found_bsr;
 }
 
+/*
+ * ***FIXME***
+ * This routine needs to be fixed to only look at items that
+ *   are not marked as done.  Otherwise, it can find a bsr
+ *   that has already been consumed, and this will cause the
+ *   bsr to be used, thus we may seek back and re-read the
+ *   same records, causing an error.  This deficiency must
+ *   be fixed.  For the moment, it has been kludged in 
+ *   read_record.c to avoid seeking back if find_next_bsr
+ *   returns a bsr pointing to a smaller address (file/block).
+ */
 static BSR *find_smallest_volfile(BSR *found_bsr, BSR *bsr)
 {
    BSR *return_bsr = found_bsr;
@@ -215,6 +245,7 @@ static BSR *find_smallest_volfile(BSR *found_bsr, BSR *bsr)
    uint32_t found_bsr_sfile, bsr_sfile;
    uint32_t found_bsr_sblock, bsr_sblock;
 
+   /* Find the smallest file in the found_bsr */
    vf = found_bsr->volfile;
    found_bsr_sfile = vf->sfile;
    while ( (vf=vf->next) ) {
@@ -222,6 +253,8 @@ static BSR *find_smallest_volfile(BSR *found_bsr, BSR *bsr)
          found_bsr_sfile = vf->sfile;
       }
    }
+
+   /* Find the smallest file in the bsr */
    vf = bsr->volfile;
    bsr_sfile = vf->sfile;
    while ( (vf=vf->next) ) {
@@ -229,10 +262,13 @@ static BSR *find_smallest_volfile(BSR *found_bsr, BSR *bsr)
          bsr_sfile = vf->sfile;
       }
    }
+    
+   /* if the bsr file is less than the found_bsr file, return bsr */
    if (found_bsr_sfile > bsr_sfile) {
       return_bsr = bsr;
    } else if (found_bsr_sfile == bsr_sfile) {
-      /* Must check block */
+      /* Files are equal */
+      /* find smallest block in found_bsr */
       vb = found_bsr->volblock;
       found_bsr_sblock = vb->sblock;
       while ( (vb=vb->next) ) {
@@ -240,6 +276,7 @@ static BSR *find_smallest_volfile(BSR *found_bsr, BSR *bsr)
             found_bsr_sblock = vb->sblock;
          }
       }
+      /* Find smallest block in bsr */
       vb = bsr->volblock;
       bsr_sblock = vb->sblock;
       while ( (vb=vb->next) ) {
@@ -247,11 +284,11 @@ static BSR *find_smallest_volfile(BSR *found_bsr, BSR *bsr)
             bsr_sblock = vb->sblock;
          }
       }
+      /* Compare and return the smallest */
       if (found_bsr_sblock > bsr_sblock) {
          return_bsr = bsr;
       }
    }
-
    return return_bsr;
 }
 
@@ -294,7 +331,7 @@ static int match_all(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec,
                      SESSION_LABEL *sessrec, bool done)
 {
    if (bsr->done) {
-      Dmsg0(dbglevel, "bsr->done set\n");
+//    Dmsg0(dbglevel, "bsr->done set\n");
       goto no_match;
    }
    if (!match_volume(bsr, bsr->volume, volrec, 1)) {
@@ -303,8 +340,8 @@ static int match_all(BSR *bsr, DEV_RECORD *rec, VOLUME_LABEL *volrec,
       goto no_match;
    }
    if (!match_volfile(bsr, bsr->volfile, rec, 1)) {
-      Dmsg2(dbglevel, "Fail on file. bsr=%d rec=%d\n", bsr->volfile->efile,
-         rec->File);
+      Dmsg3(dbglevel, "Fail on file=%d. bsr=%d,%d\n", 
+         rec->File, bsr->volfile->sfile, bsr->volfile->efile);
       goto no_match;
    }
    if (!match_sesstime(bsr, bsr->sesstime, rec, 1)) {
@@ -400,7 +437,7 @@ static int match_client(BSR *bsr, BSR_CLIENT *client, SESSION_LABEL *sessrec, bo
    if (!client) {
       return 1;                       /* no specification matches all */
    }
-   if (fnmatch(client->ClientName, sessrec->ClientName, 0) == 0) {
+   if (strcmp(client->ClientName, sessrec->ClientName) == 0) {
       return 1;
    }
    if (client->next) {
@@ -414,7 +451,7 @@ static int match_job(BSR *bsr, BSR_JOB *job, SESSION_LABEL *sessrec, bool done)
    if (!job) {
       return 1;                       /* no specification matches all */
    }
-   if (fnmatch(job->Job, sessrec->Job, 0) == 0) {
+   if (strcmp(job->Job, sessrec->Job) == 0) {
       return 1;
    }
    if (job->next) {
@@ -554,24 +591,24 @@ static int match_sessid(BSR *bsr, BSR_SESSID *sessid, DEV_RECORD *rec)
  *  ***FIXME*** optimizations
  * We could optimize a lot here by removing the recursion, and 
  *   stopping the search earlier -- say when rec->FileIndex > findex->findex2
- *   and findex->next == NULL.  Also, the current entry tests could be skipped
- *   if findex->done is set.
+ *   and findex->next == NULL.  
  */
 static int match_findex(BSR *bsr, BSR_FINDEX *findex, DEV_RECORD *rec, bool done)
 {
    if (!findex) {
       return 1;                       /* no specification matches all */
    }
-   if (findex->findex <= rec->FileIndex && findex->findex2 >= rec->FileIndex) {
-      Dmsg3(dbglevel, "Match on findex=%d. bsr=%d,%d\n",
-            rec->FileIndex, findex->findex, findex->findex2);
-      return 1;
-   }
-   if (rec->FileIndex > findex->findex2) {
-      findex->done = true;
+   if (!findex->done) {
+      if (findex->findex <= rec->FileIndex && findex->findex2 >= rec->FileIndex) {
+         Dmsg3(dbglevel, "Match on findex=%d. bsr=%d,%d\n",
+               rec->FileIndex, findex->findex, findex->findex2);
+         return 1;
+      }
+      if (rec->FileIndex > findex->findex2) {
+         findex->done = true;
+      }
    }
    if (findex->next) {
-      Dmsg0(dbglevel, "Next findex link\n");
       return match_findex(bsr, findex->next, rec, findex->done && done);
    }
    if (findex->done && done) {