X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fstored%2Fparse_bsr.c;h=654232632cf5f297b63910d80ec32969a56d14a8;hb=7503a438c87931cf1748bd0fda3bb932e2af3346;hp=ca141da4b9e2e44c91aa48d9a8a5d6120f6366df;hpb=9f8c89965e9f2d7e4fb55e9fd79a2aa83b85c985;p=bacula%2Fbacula diff --git a/bacula/src/stored/parse_bsr.c b/bacula/src/stored/parse_bsr.c index ca141da4b9..654232632c 100755 --- a/bacula/src/stored/parse_bsr.c +++ b/bacula/src/stored/parse_bsr.c @@ -1,13 +1,13 @@ -/* - * Parse a Bootstrap Records (used for restores) - * +/* + * Parse a Bootstrap Records (used for restores) + * * Kern Sibbald, June MMII * * Version $Id$ */ /* - Copyright (C) 2002 Kern Sibbald and John Walker + Copyright (C) 2002-2005 Kern Sibbald This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as @@ -21,7 +21,7 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free - MA 02111-1307, USA. + MA 02111-1307, USA. */ @@ -32,22 +32,27 @@ typedef BSR * (ITEM_HANDLER)(LEX *lc, BSR *bsr); static BSR *store_vol(LEX *lc, BSR *bsr); +static BSR *store_mediatype(LEX *lc, BSR *bsr); static BSR *store_client(LEX *lc, BSR *bsr); static BSR *store_job(LEX *lc, BSR *bsr); static BSR *store_jobid(LEX *lc, BSR *bsr); +static BSR *store_count(LEX *lc, BSR *bsr); static BSR *store_jobtype(LEX *lc, BSR *bsr); static BSR *store_joblevel(LEX *lc, BSR *bsr); static BSR *store_findex(LEX *lc, BSR *bsr); static BSR *store_sessid(LEX *lc, BSR *bsr); static BSR *store_volfile(LEX *lc, BSR *bsr); +static BSR *store_volblock(LEX *lc, BSR *bsr); static BSR *store_sesstime(LEX *lc, BSR *bsr); static BSR *store_include(LEX *lc, BSR *bsr); static BSR *store_exclude(LEX *lc, BSR *bsr); static BSR *store_stream(LEX *lc, BSR *bsr); static BSR *store_slot(LEX *lc, BSR *bsr); +static bool is_fast_rejection_ok(BSR *bsr); +static bool is_positioning_ok(BSR *bsr); struct kw_items { - char *name; + const char *name; ITEM_HANDLER *handler; }; @@ -56,9 +61,11 @@ struct kw_items { */ struct kw_items items[] = { {"volume", store_vol}, + {"mediatype", store_mediatype}, {"client", store_client}, {"job", store_job}, {"jobid", store_jobid}, + {"count", store_count}, {"fileindex", store_findex}, {"jobtype", store_jobtype}, {"joblevel", store_joblevel}, @@ -67,16 +74,17 @@ struct kw_items items[] = { {"include", store_include}, {"exclude", store_exclude}, {"volfile", store_volfile}, + {"volblock", store_volblock}, {"stream", store_stream}, {"slot", store_slot}, {NULL, NULL} }; -/* +/* * Create a BSR record */ -static BSR *new_bsr() +static BSR *new_bsr() { BSR *bsr = (BSR *)malloc(sizeof(BSR)); memset(bsr, 0, sizeof(BSR)); @@ -84,9 +92,9 @@ static BSR *new_bsr() } /* - * Format a scanner error message + * Format a scanner error message */ -static void s_err(char *file, int line, LEX *lc, char *msg, ...) +static void s_err(const char *file, int line, LEX *lc, const char *msg, ...) { JCR *jcr = (JCR *)(lc->caller_ctx); va_list arg_ptr; @@ -95,14 +103,14 @@ static void s_err(char *file, int line, LEX *lc, char *msg, ...) va_start(arg_ptr, msg); bvsnprintf(buf, sizeof(buf), msg, arg_ptr); va_end(arg_ptr); - + if (jcr) { - Jmsg(jcr, M_FATAL, 0, _("Bootstrap file error: %s\n\ - : Line %d, col %d of file %s\n%s\n"), + Jmsg(jcr, M_FATAL, 0, _("Bootstrap file error: %s\n" +" : Line %d, col %d of file %s\n%s\n"), buf, lc->line_no, lc->col_no, lc->fname, lc->line); } else { - e_msg(file, line, M_FATAL, 0, _("Bootstrap file error: %s\n\ - : Line %d, col %d of file %s\n%s\n"), + e_msg(file, line, M_FATAL, 0, _("Bootstrap file error: %s\n" +" : Line %d, col %d of file %s\n%s\n"), buf, lc->line_no, lc->col_no, lc->fname, lc->line); } } @@ -113,15 +121,15 @@ static void s_err(char *file, int line, LEX *lc, char *msg, ...) * Parse Bootstrap file * */ -BSR *parse_bsr(JCR *jcr, char *cf) +BSR *parse_bsr(JCR *jcr, char *fname) { LEX *lc = NULL; int token, i; BSR *root_bsr = new_bsr(); BSR *bsr = root_bsr; - Dmsg1(200, "Enter parse_bsf %s\n", cf); - lc = lex_open_file(lc, cf, s_err); + Dmsg1(200, "Enter parse_bsf %s\n", fname); + lc = lex_open_file(lc, fname, s_err); lc->caller_ctx = (void *)jcr; while ((token=lex_get_token(lc, T_ALL)) != T_EOF) { Dmsg1(200, "parse got token=%s\n", lex_tok_to_str(token)); @@ -160,20 +168,63 @@ BSR *parse_bsr(JCR *jcr, char *cf) free_bsr(root_bsr); root_bsr = NULL; } + if (root_bsr) { + root_bsr->use_fast_rejection = is_fast_rejection_ok(root_bsr); + root_bsr->use_positioning = is_positioning_ok(root_bsr); + } + for (bsr=root_bsr; bsr; bsr=bsr->next) { + bsr->root = root_bsr; + } return root_bsr; } +static bool is_fast_rejection_ok(BSR *bsr) +{ + /* + * Although, this can be optimized, for the moment, require + * all bsrs to have both sesstime and sessid set before + * we do fast rejection. + */ + if (!(bsr->sesstime && bsr->sessid)) { + return false; + } + if (bsr->next) { + return is_fast_rejection_ok(bsr->next); + } + return true; +} + +static bool is_positioning_ok(BSR *bsr) +{ + /* + * Every bsr should have a volfile entry and a volblock entry + * if we are going to use positioning + */ + if (!bsr->volfile || !bsr->volblock) { + return false; + } + if (bsr->next) { + return is_positioning_ok(bsr->next); + } + return true; +} + + static BSR *store_vol(LEX *lc, BSR *bsr) { int token; BSR_VOLUME *volume; char *p, *n; - + token = lex_get_token(lc, T_STRING); if (token == T_ERROR) { return NULL; } - /* This may actually be more than one volume separated by a | + if (bsr->volume) { + bsr->next = new_bsr(); + bsr = bsr->next; + } + /* This may actually be more than one volume separated by a | * If so, separate them. */ for (p=lc->str; p && *p; ) { @@ -183,13 +234,13 @@ static BSR *store_vol(LEX *lc, BSR *bsr) } volume = (BSR_VOLUME *)malloc(sizeof(BSR_VOLUME)); memset(volume, 0, sizeof(BSR_VOLUME)); - strcpy(volume->VolumeName, p); + bstrncpy(volume->VolumeName, p, sizeof(volume->VolumeName)); /* Add it to the end of the volume chain */ if (!bsr->volume) { bsr->volume = volume; } else { BSR_VOLUME *bc = bsr->volume; - for ( ;bc->next; bc=bc->next) + for ( ;bc->next; bc=bc->next) { } bc->next = volume; } @@ -198,11 +249,33 @@ static BSR *store_vol(LEX *lc, BSR *bsr) return bsr; } +/* Shove the MediaType in each Volume in the current bsr */ +static BSR *store_mediatype(LEX *lc, BSR *bsr) +{ + int token; + + token = lex_get_token(lc, T_STRING); + if (token == T_ERROR) { + return NULL; + } + if (!bsr->volume) { + Emsg1(M_ERROR,0, _("MediaType %s in bsr at inappropriate place.\n"), + lc->str); + return bsr; + } + BSR_VOLUME *bv; + for (bv=bsr->volume; bv; bv=bv->next) { + bstrncpy(bv->MediaType, lc->str, sizeof(bv->MediaType)); + } + return bsr; +} + + static BSR *store_client(LEX *lc, BSR *bsr) { int token; BSR_CLIENT *client; - + for (;;) { token = lex_get_token(lc, T_NAME); if (token == T_ERROR) { @@ -210,13 +283,13 @@ static BSR *store_client(LEX *lc, BSR *bsr) } client = (BSR_CLIENT *)malloc(sizeof(BSR_CLIENT)); memset(client, 0, sizeof(BSR_CLIENT)); - strcpy(client->ClientName, lc->str); + bstrncpy(client->ClientName, lc->str, sizeof(client->ClientName)); /* Add it to the end of the client chain */ if (!bsr->client) { bsr->client = client; } else { BSR_CLIENT *bc = bsr->client; - for ( ;bc->next; bc=bc->next) + for ( ;bc->next; bc=bc->next) { } bc->next = client; } @@ -232,7 +305,7 @@ static BSR *store_job(LEX *lc, BSR *bsr) { int token; BSR_JOB *job; - + for (;;) { token = lex_get_token(lc, T_NAME); if (token == T_ERROR) { @@ -240,7 +313,7 @@ static BSR *store_job(LEX *lc, BSR *bsr) } job = (BSR_JOB *)malloc(sizeof(BSR_JOB)); memset(job, 0, sizeof(BSR_JOB)); - strcpy(job->Job, lc->str); + bstrncpy(job->Job, lc->str, sizeof(job->Job)); /* Add it to the end of the client chain */ if (!bsr->job) { bsr->job = job; @@ -324,6 +397,21 @@ static BSR *store_jobid(LEX *lc, BSR *bsr) return bsr; } + +static BSR *store_count(LEX *lc, BSR *bsr) +{ + int token; + + token = lex_get_token(lc, T_PINT32); + if (token == T_ERROR) { + return NULL; + } + bsr->count = lc->pint32_val; + scan_to_eol(lc); + return bsr; +} + + static BSR *store_jobtype(LEX *lc, BSR *bsr) { /* *****FIXME****** */ @@ -343,7 +431,7 @@ static BSR *store_joblevel(LEX *lc, BSR *bsr) /* - * Routine to handle Volume start/end file + * Routine to handle Volume start/end file */ static BSR *store_volfile(LEX *lc, BSR *bsr) { @@ -378,6 +466,41 @@ static BSR *store_volfile(LEX *lc, BSR *bsr) } +/* + * Routine to handle Volume start/end Block + */ +static BSR *store_volblock(LEX *lc, BSR *bsr) +{ + int token; + BSR_VOLBLOCK *volblock; + + for (;;) { + token = lex_get_token(lc, T_PINT32_RANGE); + if (token == T_ERROR) { + return NULL; + } + volblock = (BSR_VOLBLOCK *)malloc(sizeof(BSR_VOLBLOCK)); + memset(volblock, 0, sizeof(BSR_VOLBLOCK)); + volblock->sblock = lc->pint32_val; + volblock->eblock = lc->pint32_val2; + /* Add it to the end of the chain */ + if (!bsr->volblock) { + bsr->volblock = volblock; + } else { + /* Add to end of chain */ + BSR_VOLBLOCK *bs = bsr->volblock; + for ( ;bs->next; bs=bs->next) + { } + bs->next = volblock; + } + token = lex_get_token(lc, T_ALL); + if (token != T_COMMA) { + break; + } + } + return bsr; +} + static BSR *store_sessid(LEX *lc, BSR *bsr) { @@ -507,6 +630,15 @@ void dump_volfile(BSR_VOLFILE *volfile) } } +void dump_volblock(BSR_VOLBLOCK *volblock) +{ + if (volblock) { + Dmsg2(-1, "VolBlock : %u-%u\n", volblock->sblock, volblock->eblock); + dump_volblock(volblock->next); + } +} + + void dump_findex(BSR_FINDEX *FileIndex) { if (FileIndex) { @@ -580,26 +712,42 @@ void dump_sesstime(BSR_SESSTIME *sesstime) -void dump_bsr(BSR *bsr) +void dump_bsr(BSR *bsr, bool recurse) { + int save_debug = debug_level; + debug_level = 1; if (!bsr) { Dmsg0(-1, "BSR is NULL\n"); + debug_level = save_debug; return; } - Dmsg1(-1, -"Next : 0x%x\n", bsr->next); + Dmsg1(-1, "Next : 0x%x\n", bsr->next); + Dmsg1(-1, "Root bsr : 0x%x\n", bsr->root); dump_volume(bsr->volume); dump_sessid(bsr->sessid); dump_sesstime(bsr->sesstime); dump_volfile(bsr->volfile); + dump_volblock(bsr->volblock); dump_client(bsr->client); dump_jobid(bsr->JobId); dump_job(bsr->job); dump_findex(bsr->FileIndex); - if (bsr->next) { + if (bsr->Slot) { + Dmsg1(-1, "Slot : %u\n", bsr->Slot); + } + if (bsr->count) { + Dmsg1(-1, "count : %u\n", bsr->count); + Dmsg1(-1, "found : %u\n", bsr->found); + } + + Dmsg1(-1, "done : %s\n", bsr->done?"yes":"no"); + Dmsg1(-1, "positioning : %d\n", bsr->use_positioning); + Dmsg1(-1, "fast_reject : %d\n", bsr->use_fast_rejection); + if (recurse && bsr->next) { Dmsg0(-1, "\n"); - dump_bsr(bsr->next); + dump_bsr(bsr->next, true); } + debug_level = save_debug; } @@ -627,6 +775,7 @@ void free_bsr(BSR *bsr) free_bsr_item((BSR *)bsr->sessid); free_bsr_item((BSR *)bsr->sesstime); free_bsr_item((BSR *)bsr->volfile); + free_bsr_item((BSR *)bsr->volblock); free_bsr_item((BSR *)bsr->JobId); free_bsr_item((BSR *)bsr->job); free_bsr_item((BSR *)bsr->FileIndex); @@ -637,7 +786,7 @@ void free_bsr(BSR *bsr) } /***************************************************************** - * Routines for handling volumes + * Routines for handling volumes */ VOL_LIST *new_vol() { @@ -647,7 +796,7 @@ VOL_LIST *new_vol() return vol; } -/* +/* * Add current volume to end of list, only if the Volume * is not already in the list. * @@ -663,10 +812,16 @@ int add_vol(JCR *jcr, VOL_LIST *vol) } else { for ( ; next->next; next=next->next) { if (strcmp(vol->VolumeName, next->VolumeName) == 0) { + if (vol->start_file < next->start_file) { + next->start_file = vol->start_file; + } return 0; /* already in list */ } } if (strcmp(vol->VolumeName, next->VolumeName) == 0) { + if (vol->start_file < next->start_file) { + next->start_file = vol->start_file; + } return 0; /* already in list */ } next->next = vol; /* add volume */ @@ -684,47 +839,66 @@ void free_vol_list(JCR *jcr) free(next); next = tmp; } + jcr->VolList = NULL; } +/* + * Create a list of Volumes (and Slots and Start positions) to be + * used in the current restore job. + */ void create_vol_list(JCR *jcr) { char *p, *n; VOL_LIST *vol; - /* - * Build a list of volume to be processed + /* + * Build a list of volumes to be processed */ jcr->NumVolumes = 0; - jcr->CurVolume = 1; + jcr->CurVolume = 0; if (jcr->bsr) { BSR *bsr = jcr->bsr; if (!bsr->volume || !bsr->volume->VolumeName) { return; } - strcpy(jcr->VolumeName, bsr->volume->VolumeName); /* setup first volume */ for ( ; bsr; bsr=bsr->next) { - BSR_VOLUME *bsrvol = bsr->volume; - for ( ; bsrvol; bsrvol=bsrvol->next) { + BSR_VOLUME *bsrvol; + BSR_VOLFILE *volfile; + uint32_t sfile = UINT32_MAX; + + /* Find minimum start file so that we can forward space to it */ + for (volfile = bsr->volfile; volfile; volfile=volfile->next) { + if (volfile->sfile < sfile) { + sfile = volfile->sfile; + } + } + /* Now add volumes for this bsr */ + for (bsrvol = bsr->volume; bsrvol; bsrvol=bsrvol->next) { vol = new_vol(); - strcpy(vol->VolumeName, bsrvol->VolumeName); + bstrncpy(vol->VolumeName, bsrvol->VolumeName, sizeof(vol->VolumeName)); + bstrncpy(vol->MediaType, bsrvol->MediaType, sizeof(vol->MediaType)); + vol->start_file = sfile; if (add_vol(jcr, vol)) { jcr->NumVolumes++; - Dmsg1(400, "Added volume %s\n", vol->VolumeName); + Dmsg2(400, "Added volume=%s mediatype=%s\n", vol->VolumeName, + vol->MediaType); } else { Dmsg1(400, "Duplicate volume %s\n", vol->VolumeName); free((char *)vol); } + sfile = 0; /* start at beginning of second volume */ } } } else { - /* This is the old way -- deprecated */ - for (p = jcr->VolumeName; p && *p; ) { + /* This is the old way -- deprecated */ + for (p = jcr->dcr->VolumeName; p && *p; ) { n = strchr(p, '|'); /* volume name separator */ if (n) { *n++ = 0; /* Terminate name */ } vol = new_vol(); - strcpy(vol->VolumeName, p); + bstrncpy(vol->VolumeName, p, sizeof(vol->VolumeName)); + bstrncpy(vol->MediaType, jcr->dcr->media_type, sizeof(vol->MediaType)); if (add_vol(jcr, vol)) { jcr->NumVolumes++; } else {