#include <afsconfig.h>
#include <afs/param.h>
-RCSID
- ("$Header$");
#include <afs/stds.h>
#include <sys/types.h>
#ifdef AFS_NT40_ENV
#include <winsock2.h>
#else
-#include <strings.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <afs/budb.h>
#include <afs/vlserver.h>
#include "error_macros.h"
+#include "bucoord_internal.h"
+#include "bucoord_prototypes.h"
extern struct bc_dumpTask bc_dumpTasks[BC_MAXSIMDUMPS];
extern char *whoami;
-#define BC_MAXLEVELS 20
#define MAXTAPESATONCE 10
#define HOSTADDR(sockaddr) (sockaddr)->sin_addr.s_addr
};
struct volinfo {
- struct voli *next;
+ struct volinfo *next;
char *volname;
afs_int32 server;
afs_int32 partition;
};
/* strip .backup from the end of a name */
-static
-StripBackup(aname)
- register char *aname;
+static int
+StripBackup(char *aname)
{
int j;
- if (j = BackupName(aname)) {
+ if ((j = BackupName(aname))) {
aname[j] = 0;
return 0;
}
}
int
-BackupName(aname)
- char *aname;
+BackupName(char *aname)
{
int j;
return 0;
}
-extractTapeSeq(tapename)
- char *tapename;
+int
+extractTapeSeq(char *tapename)
{
char *sptr;
return (atol(sptr));
}
-viceName(value)
- long value;
+void
+viceName(long value)
{
char *alph;
int r;
* entry:
* aindex - index into bc_dumpTasks that describes this dump.
*/
-bc_Restorer(aindex)
- afs_int32 aindex;
+int
+bc_Restorer(afs_int32 aindex)
{
struct bc_dumpTask *dumpTaskPtr;
afs_int32 tapedumpid, parent;
afs_int32 nentries = 0;
- afs_int32 last, next, ve, vecount;
+ afs_int32 last = 0;
+ afs_int32 next, ve, vecount;
struct bc_tapeItem *ti, *pti, *nti;
struct bc_tapeList *tapeList = (struct bc_tapeList *)0;
struct bc_tapeList *tle, *ptle, *ntle;
statusP statusPtr, newStatusPtr;
struct dumpinfo *dumpinfolist = NULL;
- struct dumpinfo *pdi, *ndi, *di, dlevels[BC_MAXLEVELS];
- struct volinfo *pvi, *nvi, *vi;
+ struct dumpinfo *pdi, *ndi, *di, *dlevels;
+ struct volinfo *nvi, *vi;
afs_int32 lvl, lv;
+ int num_dlevels = 20;
afs_int32 serverAll; /* The server to which all volumes are to be restore to */
afs_int32 partitionAll; /* Likewise for partition */
time_t did;
int foundtape, c;
- extern statusP createStatusNode();
- extern statusP findStatus();
+ dlevels = (struct dumpinfo *) malloc(num_dlevels * sizeof(*dlevels));
dumpTaskPtr = &bc_dumpTasks[aindex];
serverAll = HOSTADDR(&dumpTaskPtr->destServer);
volumeEntries = (struct budb_volumeEntry *)
malloc(MAXTAPESATONCE * sizeof(struct budb_volumeEntry));
if (!volumeEntries) {
- com_err(whoami, BC_NOMEM, "");
+ afs_com_err(whoami, BC_NOMEM, "");
ERROR(BC_NOMEM);
}
for (tvol = dumpTaskPtr->volumes; tvol; tvol = tvol->next) { /*tvol */
strcpy(vname, tvol->name);
dumpDescr = &dumpDescr1;
- code = bcdb_FindDump(vname, dumpTaskPtr->fromDate, dumpDescr);
-
- if (!BackupName(vname)) { /* See if backup volume is there */
- strcat(vname, ".backup");
- dumpDescr = &dumpDescr2;
- tcode = code;
+ if (dumpTaskPtr->parentDumpID > 0) /* Told which dump to try */
+ {
+ /* Right now, this assumes that all volumes listed will be
+ * from the given dumpID. FIXME
+ */
+ code = bcdb_FindDumpByID(dumpTaskPtr->parentDumpID, dumpDescr);
+ if (code)
+ {
+ afs_com_err(whoami, code, "Couldn't look up info for dump %d\n",
+ dumpTaskPtr->parentDumpID);
+ continue;
+ }
+ code = bcdb_FindVolumes(dumpTaskPtr->parentDumpID, vname, volumeEntries,
+ last, &next, MAXTAPESATONCE, &vecount);
+ if (code)
+ {
+ if (!BackupName(vname))
+ {
+ strcat(vname, ".backup");
+ code = bcdb_FindVolumes(dumpTaskPtr->parentDumpID, vname, volumeEntries,
+ last, &next, MAXTAPESATONCE, &vecount);
+ }
+ }
+ }
+ else
+ {
code = bcdb_FindDump(vname, dumpTaskPtr->fromDate, dumpDescr);
+ if (!BackupName(vname)) { /* See if backup volume is there */
+ strcat(vname, ".backup");
+ dumpDescr = &dumpDescr2;
+ tcode = code;
+ code = bcdb_FindDump(vname, dumpTaskPtr->fromDate, dumpDescr);
- if (code) { /* Can't find backup, go with first results */
+ if (code) { /* Can't find backup, go with first results */
strcpy(vname, tvol->name);
dumpDescr = &dumpDescr1;
code = tcode;
- } else if (!tcode) { /* Both found an entry, go with latest result */
+ } else if (!tcode) { /* Both found an entry, go with latest result */
if (dumpDescr1.created > dumpDescr2.created) {
- strcpy(vname, tvol->name);
- dumpDescr = &dumpDescr1;
- code = tcode;
+ strcpy(vname, tvol->name);
+ dumpDescr = &dumpDescr1;
+ code = tcode;
}
+ }
}
- }
+ }
if (code) { /* If FindDump took an error */
- com_err(whoami, code, "; Can't find any dump for volume %s",
+ afs_com_err(whoami, code, "; Can't find any dump for volume %s",
tvol->name);
continue;
}
if (!di) {
di = (struct dumpinfo *)malloc(sizeof(struct dumpinfo));
if (!di) {
- com_err(whoami, BC_NOMEM, "");
+ afs_com_err(whoami, BC_NOMEM, "");
ERROR(BC_NOMEM);
}
memset(di, 0, sizeof(struct dumpinfo));
/* Create one and thread into list */
vi = (struct volinfo *)malloc(sizeof(struct volinfo));
if (!vi) {
- com_err(whoami, BC_NOMEM, "");
+ afs_com_err(whoami, BC_NOMEM, "");
ERROR(BC_NOMEM);
}
memset(vi, 0, sizeof(struct volinfo));
vi->volname = (char *)malloc(strlen(vname) + 1);
if (!vi->volname) {
free(vi);
- com_err(whoami, BC_NOMEM, "");
+ afs_com_err(whoami, BC_NOMEM, "");
ERROR(BC_NOMEM);
}
memcpy(&dlevels[0], di, sizeof(struct dumpinfo));
for (lvl = 1, parent = dlevels[0].parentDumpId; parent;
parent = dlevels[lvl].parentDumpId, lvl++) {
+ if (lvl >= num_dlevels) { /* running out of dump levels */
+ struct dumpinfo *tdl = dlevels;
+
+ num_dlevels += num_dlevels; /* double */
+ dlevels = (struct dumpinfo *) malloc(num_dlevels * sizeof(*dlevels));
+ memcpy(dlevels, tdl, (num_dlevels/2) * sizeof(*dlevels));
+ free(tdl);
+ }
code = bcdb_FindDumpByID(parent, &dumpDescr1);
if (code) {
for (vi = di->volinfolist; vi; vi = vi->next) {
- com_err(whoami, code,
+ afs_com_err(whoami, code,
"; Can't find parent DumpID %u for volume %s",
parent, vi->volname);
}
break;
}
- com_err(whoami, code,
+ afs_com_err(whoami, code,
"; Can't find volume %s in DumpID %u",
vi->volname, dlevels[lv].DumpId);
ERROR(code);
tle = (struct bc_tapeList *)
malloc(sizeof(struct bc_tapeList));
if (!tle) {
- com_err(whoami, BC_NOMEM, "");
+ afs_com_err(whoami, BC_NOMEM, "");
return (BC_NOMEM);
}
memset(tle, 0, sizeof(struct bc_tapeList));
+ 1);
if (!tle->tapeName) {
free(tle);
- com_err(whoami, BC_NOMEM, "");
+ afs_com_err(whoami, BC_NOMEM, "");
return (BC_NOMEM);
}
ti = (struct bc_tapeItem *)
malloc(sizeof(struct bc_tapeItem));
if (!ti) {
- com_err(whoami, BC_NOMEM, "");
+ afs_com_err(whoami, BC_NOMEM, "");
return (BC_NOMEM);
}
memset(ti, 0, sizeof(struct bc_tapeItem));
+ 1);
if (!ti->volumeName) {
free(ti);
- com_err(whoami, BC_NOMEM, "");
+ afs_com_err(whoami, BC_NOMEM, "");
return (BC_NOMEM);
}
} /* di: For each dump */
if (!nentries) {
- com_err(whoami, 0, "No volumes to restore");
+ afs_com_err(whoami, 0, "No volumes to restore");
ERROR(0);
}
(struct tc_restoreDesc *)malloc(nentries *
sizeof(struct tc_restoreDesc));
if (!tcarray) {
- com_err(whoami, BC_NOMEM, "");
+ afs_com_err(whoami, BC_NOMEM, "");
ERROR(BC_NOMEM);
}
memset(tcarray, 0, nentries * sizeof(struct tc_restoreDesc));
TC_PerformRestore(aconn, "DumpSetName", &rpcArray,
&dumpTaskPtr->dumpID);
if (code) {
- com_err(whoami, code, "; Failed to start restore");
+ afs_com_err(whoami, code, "; Failed to start restore");
break;
}
if (volumeEntries)
free(volumeEntries);
+ free(dlevels);
+
return code;
}
git://git.openafs.org / openafs.git / blobdiff