-/* Copyright (C) 1998 Transarc Corporation - All rights reserved */
/*
- * (C) COPYRIGHT TRANSARC CORPORATION 1989
- * LICENSED MATERIALS - PROPERTY OF TRANSARC
+ * Copyright 2000, International Business Machines Corporation and others.
+ * All Rights Reserved.
+ *
+ * This software has been released under the terms of the IBM Public
+ * License. For details, see the LICENSE file in the top-level source
+ * directory or online at http://www.openafs.org/dl/license10.html
+ */
+
+/*
* ALL RIGHTS RESERVED
*/
+#include <afsconfig.h>
#include <afs/param.h>
+
+
#include <afs/stds.h>
#include <sys/types.h>
#include <afs/cmd.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_config *bc_globalConfig;
extern struct bc_dumpTask bc_dumpTasks[BC_MAXSIMDUMPS];
-extern void bc_HandleMisc();
extern char *whoami;
-extern struct rx_connection *bc_GetConn();
-
-#ifdef AFS_SGI64_ENV
-extern char *rindex();
-#endif
-#define BC_MAXLEVELS 20
#define MAXTAPESATONCE 10
-#ifdef AFS_DEC_ENV
-#define HOSTADDR(sockaddr) (sockaddr)->sin_addr.S_un.S_addr
-#else
#define HOSTADDR(sockaddr) (sockaddr)->sin_addr.s_addr
-#endif
/* local structure to keep track of volumes and the dumps from which
* they should be restored
*/
-struct dumpinfo
-{
- struct dumpinfo *next;
- struct volinfo *volinfolist;
- struct volinfo *lastinlist;
- afs_int32 DumpId;
- afs_int32 initialDumpId;
- afs_int32 parentDumpId;
- afs_int32 level;
+struct dumpinfo {
+ struct dumpinfo *next;
+ struct volinfo *volinfolist;
+ struct volinfo *lastinlist;
+ afs_int32 DumpId;
+ afs_int32 initialDumpId;
+ afs_int32 parentDumpId;
+ afs_int32 level;
};
-struct volinfo
-{
- struct voli *next;
- char *volname;
- afs_int32 server;
- afs_int32 partition;
+struct volinfo {
+ struct volinfo *next;
+ char *volname;
+ afs_uint32 server;
+ afs_int32 partition;
};
/* local structure used to keep track of a tape, including a list of
* volumes to restore from that tape (bc_tapeItem)
*/
-struct bc_tapeList
-{
- struct bc_tapeList *next; /* next guy in list */
- char *tapeName; /* name of the tape */
- afs_int32 dumpID; /* dump located on this tape */
- afs_int32 initialDumpID; /* initial dump located on this tape */
- afs_int32 tapeNumber; /* which tape in the dump */
- struct bc_tapeItem *restoreList; /* volumes to restore from this tape */
+struct bc_tapeList {
+ struct bc_tapeList *next; /* next guy in list */
+ char *tapeName; /* name of the tape */
+ afs_int32 dumpID; /* dump located on this tape */
+ afs_int32 initialDumpID; /* initial dump located on this tape */
+ afs_int32 tapeNumber; /* which tape in the dump */
+ struct bc_tapeItem *restoreList; /* volumes to restore from this tape */
};
/* each tape has a list of volumes to restore; hangs off of a struct
bc_tapeList. Kept sorted so that we can read the tape once to do
everything we need to do. */
-struct bc_tapeItem
-{
+struct bc_tapeItem {
struct bc_tapeItem *next;
- char *volumeName; /* volume to restore */
- afs_int32 position; /* file slot on this tape */
- afs_int32 oid; /* id of the volume */
- afs_int32 dumplevel; /* level # of the containing dump (0 == top level) */
- afs_int32 vollevel; /* level # of the containing volume (0 == full dump) */
+ char *volumeName; /* volume to restore */
+ afs_int32 position; /* file slot on this tape */
+ afs_int32 oid; /* id of the volume */
+ afs_int32 dumplevel; /* level # of the containing dump (0 == top level) */
+ afs_int32 vollevel; /* level # of the containing volume (0 == full dump) */
afs_uint32 server;
afs_int32 partition;
- int lastdump; /* The last incremental to restore */
+ int lastdump; /* The last incremental to restore */
};
/* 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)) {
- aname[j] = 0;
+
+ if ((j = BackupName(aname))) {
+ aname[j] = 0;
return 0;
}
return -1;
}
-int BackupName(aname)
- char *aname;
+int
+BackupName(char *aname)
{
int j;
j = strlen(aname);
- if ((j > 7) && (strcmp(".backup", aname+j-7) == 0))
- return (j-7);
- if ((j > 9) && (strcmp(".readonly", aname+j-9) == 0))
- return (j-9);
+ if ((j > 7) && (strcmp(".backup", aname + j - 7) == 0))
+ return (j - 7);
+ if ((j > 9) && (strcmp(".readonly", aname + j - 9) == 0))
+ return (j - 9);
return 0;
}
-extractTapeSeq(tapename)
- char *tapename;
+int
+extractTapeSeq(char *tapename)
{
char *sptr;
- sptr = rindex(tapename, '.');
- if ( !sptr ) return(-1);
+ sptr = strrchr(tapename, '.');
+ if (!sptr)
+ return (-1);
sptr++;
- return(atol(sptr));
+ return (atol(sptr));
}
-viceName(value)
- long value;
+void
+viceName(long value)
{
- char *alph;
- int r;
+ char *alph;
+ int r;
- alph = "abcdefjhijklmnopqrstuvwxyz";
+ alph = "abcdefjhijklmnopqrstuvwxyz";
- if (value > 25)
- viceName(value/26 - 1);
+ if (value > 25)
+ viceName(value / 26 - 1);
- r = value % 26;
- printf("%c", alph[r]);
+ r = value % 26;
+ printf("%c", alph[r]);
}
/* bc_DoRestore
* 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;
- char vname[BU_MAXNAMELEN];
+ char vname[BU_MAXNAMELEN];
struct budb_dumpEntry *dumpDescr, dumpDescr1, dumpDescr2;
struct budb_volumeEntry *volumeEntries;
struct bc_volumeDump *tvol;
- afs_int32 code = 0, tcode;
- afs_int32 tapedumpid, parent;
+ afs_int32 code = 0, tcode;
+ afs_int32 tapedumpid, parent;
- afs_int32 nentries = 0;
- afs_int32 last, next, ve, vecount;
+ afs_int32 nentries = 0;
+ 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;
- afs_int32 tlid;
- afs_int32 tapeid, tid;
+ afs_int32 tlid;
+ afs_int32 tapeid, tid;
- struct tc_restoreArray rpcArray; /* the rpc structure we use */
- struct tc_restoreDesc *tcarray = (struct tc_restoreDesc *)0;
+ struct tc_restoreArray rpcArray; /* the rpc structure we use */
+ struct tc_restoreDesc *tcarray = (struct tc_restoreDesc *)0;
afs_int32 i, startentry, todump;
afs_int32 port, nextport;
struct rx_connection *aconn = (struct rx_connection *)0;
statusP statusPtr, newStatusPtr;
- struct dumpinfo *dumpinfolist = (struct dumpinfo *)0;
- struct dumpinfo *pdi, *ndi, *di, dlevels[BC_MAXLEVELS];
- struct volinfo *pvi, *nvi, *vi;
- afs_int32 lvl, lv;
+ struct dumpinfo *dumpinfolist = NULL;
+ 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 */
- struct hostent *hostPtr;
- long haddr;
- u_long did;
- int foundtape, c;
+ afs_uint32 serverAll; /* The server to which all volumes are to be restore to */
+ afs_int32 partitionAll; /* Likewise for partition */
+ struct hostent *hostPtr;
+ long haddr;
+ 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);
+ dumpTaskPtr = &bc_dumpTasks[aindex];
+ serverAll = HOSTADDR(&dumpTaskPtr->destServer);
partitionAll = dumpTaskPtr->destPartition;
volumeEntries = (struct budb_volumeEntry *)
- malloc(MAXTAPESATONCE * sizeof(struct budb_volumeEntry));
- if (!volumeEntries)
- {
- com_err(whoami,BC_NOMEM,"");
+ malloc(MAXTAPESATONCE * sizeof(struct budb_volumeEntry));
+ if (!volumeEntries) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
ERROR(BC_NOMEM);
}
-
+
/* For each volume to restore, find which dump it's most recent full or
* incremental is on and thread onto our dump list (from oldest to newest
* dump). Also hang the volume off of the dump (no particular order).
*/
- for (tvol = dumpTaskPtr->volumes; tvol; tvol = tvol->next)
- { /*tvol*/
- strcpy(vname, tvol->name);
+ 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 (code) /* Can't find backup, go with first results */
- {
- strcpy(vname, tvol->name);
+ 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 */
+ strcpy(vname, tvol->name);
dumpDescr = &dumpDescr1;
code = tcode;
- }
- else if (!tcode) /* Both found an entry, go with latest result */
- {
- if (dumpDescr1.created > dumpDescr2.created)
- {
- strcpy(vname, tvol->name);
- dumpDescr = &dumpDescr1;
- code = tcode;
+ } else if (!tcode) { /* Both found an entry, go with latest result */
+ if (dumpDescr1.created > dumpDescr2.created) {
+ 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", tvol->name);
+ if (code) { /* If FindDump took an error */
+ afs_com_err(whoami, code, "; Can't find any dump for volume %s",
+ tvol->name);
continue;
}
-
+
/* look to see if this dump has already been found */
- for (pdi=0, di=dumpinfolist; di; pdi=di, di=di->next)
- {
- if (di->DumpId < dumpDescr->id) { di = 0; break; }
- else if (di->DumpId == dumpDescr->id) { break; }
+ for (pdi = 0, di = dumpinfolist; di; pdi = di, di = di->next) {
+ if (di->DumpId < dumpDescr->id) {
+ di = 0;
+ break;
+ } else if (di->DumpId == dumpDescr->id) {
+ break;
+ }
}
/* If didn't find it, create one and thread into list */
- if (!di)
- {
- di = (struct dumpinfo *) malloc(sizeof(struct dumpinfo));
- if (!di)
- {
- com_err(whoami,BC_NOMEM,"");
+ if (!di) {
+ di = (struct dumpinfo *)malloc(sizeof(struct dumpinfo));
+ if (!di) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
ERROR(BC_NOMEM);
}
- bzero (di, sizeof(struct dumpinfo));
+ memset(di, 0, sizeof(struct dumpinfo));
- di->DumpId = dumpDescr->id;
+ di->DumpId = dumpDescr->id;
di->initialDumpId = dumpDescr->initialDumpID;
- di->parentDumpId = dumpDescr->parent;
- di->level = dumpDescr->level;
-
- if (!pdi)
- {
- di->next = dumpinfolist;
- dumpinfolist = di;
- }
- else
- {
- di->next = pdi->next;
- pdi->next = di;
+ di->parentDumpId = dumpDescr->parent;
+ di->level = dumpDescr->level;
+
+ if (!pdi) {
+ di->next = dumpinfolist;
+ dumpinfolist = di;
+ } else {
+ di->next = pdi->next;
+ pdi->next = di;
}
}
-
+
/* Create one and thread into list */
- vi = (struct volinfo *) malloc(sizeof(struct volinfo));
- if (!vi)
- {
- com_err(whoami,BC_NOMEM,"");
+ vi = (struct volinfo *)malloc(sizeof(struct volinfo));
+ if (!vi) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
ERROR(BC_NOMEM);
}
- bzero (vi, sizeof(struct volinfo));
-
- vi->volname = (char*)malloc(strlen(vname)+1);
- if (!vi->volname)
- {
+ 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, NULL);
ERROR(BC_NOMEM);
}
strcpy(vi->volname, vname);
- if (serverAll)
- {
- vi->server = serverAll;
+ if (serverAll) {
+ vi->server = serverAll;
vi->partition = partitionAll;
- }
- else
- {
- vi->server = HOSTADDR(&tvol->server);
+ } else {
+ vi->server = HOSTADDR(&tvol->server);
vi->partition = tvol->partition;
}
/* thread onto end of list */
- if (!di->lastinlist) di->volinfolist = vi;
- else di->lastinlist->next = vi;
+ if (!di->lastinlist)
+ di->volinfolist = vi;
+ else
+ di->lastinlist->next = vi;
di->lastinlist = vi;
- } /*tvol*/
+ } /*tvol */
/* For each of the above dumps we found (they could be increments), find
* the dump's lineage (up to the full dump).
*/
- for (di=dumpinfolist; di; di=di->next)
- {
+ for (di = dumpinfolist; di; di = di->next) {
/* Find each of the parent dumps */
- bcopy(di, &dlevels[0], sizeof(struct dumpinfo));
- for (lvl=1, parent=dlevels[0].parentDumpId; parent;
- parent=dlevels[lvl].parentDumpId, lvl++)
- {
+ 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, "; Can't find parent DumpID %u for volume %s",
+ if (code) {
+ for (vi = di->volinfolist; vi; vi = vi->next) {
+ afs_com_err(whoami, code,
+ "; Can't find parent DumpID %u for volume %s",
parent, vi->volname);
}
break;
}
- dlevels[lvl].DumpId = dumpDescr1.id;
+ dlevels[lvl].DumpId = dumpDescr1.id;
dlevels[lvl].initialDumpId = dumpDescr1.initialDumpID;
- dlevels[lvl].parentDumpId = dumpDescr1.parent;
- dlevels[lvl].level = dumpDescr1.level;
+ dlevels[lvl].parentDumpId = dumpDescr1.parent;
+ dlevels[lvl].level = dumpDescr1.level;
}
/* For each of the volumes that has a dump in this lineage (vi),
* Each volume fragment is sorted by tapeid, tape sequence, and tape
* position.
*/
- for (vi=di->volinfolist; vi; vi=vi->next)
- {
- tle = tapeList; /* Use for searching the tapelist */
- ptle = 0; /* The previous tape list entry */
- tlid = 0; /* tapeid of first entry */
+ for (vi = di->volinfolist; vi; vi = vi->next) {
+ tle = tapeList; /* Use for searching the tapelist */
+ ptle = 0; /* The previous tape list entry */
+ tlid = 0; /* tapeid of first entry */
/* Volume's dump-level. May not be same as dump's dump-level. This
* value gets incremented everytime the volume is found on a dump.
*/
voldumplevel = 0;
/* Do from level 0 dump to highest level dump */
- for (lv=(lvl-1); lv>=0; lv--)
- {
- foundvolume = 0; /* If found volume on this dump */
- tapeid = (dlevels[lv].initialDumpId ? dlevels[lv].initialDumpId :
- dlevels[lv].DumpId);
-
- /* Cycle through the volume fragments for this volume on the tape */
- for (last=0,c=0; last>=0; last=next,c++)
- {
- code = bcdb_FindVolumes(dlevels[lv].DumpId, vi->volname, volumeEntries,
- last, &next, MAXTAPESATONCE, &vecount);
- if (code)
- {
- /* Volume wasn't found on the tape - so continue.
+ for (lv = (lvl - 1); lv >= 0; lv--) {
+ foundvolume = 0; /* If found volume on this dump */
+ tapeid =
+ (dlevels[lv].initialDumpId ? dlevels[lv].
+ initialDumpId : dlevels[lv].DumpId);
+
+ /* Cycle through the volume fragments for this volume on the tape */
+ for (last = 0, c = 0; last >= 0; last = next, c++) {
+ code =
+ bcdb_FindVolumes(dlevels[lv].DumpId, vi->volname,
+ volumeEntries, last, &next,
+ MAXTAPESATONCE, &vecount);
+ if (code) {
+ /* Volume wasn't found on the tape - so continue.
* This can happen when volume doesn't exist during level 0 dump
* but exists for incremental dump.
*/
- if (code == BUDB_ENDOFLIST)
- {
+ if (code == BUDB_ENDOFLIST) {
code = 0;
break;
}
- com_err(whoami, code, "; Can't find volume %s in DumpID %u",
+ afs_com_err(whoami, code,
+ "; Can't find volume %s in DumpID %u",
vi->volname, dlevels[lv].DumpId);
ERROR(code);
}
-
+
/* If we have made the Findvolumes call more than once for the same
* volume, then begin the search at the top. This sort assumes that
* we are collecting information from lowest level dump (full dump)
* there is more than one call to FindVolumes, this is not true
* anymore.
*/
- if (c)
- {
- tle = tapeList;
+ if (c) {
+ tle = tapeList;
ptle = 0;
tlid = 0;
}
* the list of tapes they are on. Sort by tapeid, then tape sequence.
* Do from first fragment (where volume begins) to last fragment.
*/
- for (ve=(vecount-1); ve>=0; ve--)
- {
- foundvolume = 1; /* Found the volume on this dump */
+ for (ve = (vecount - 1); ve >= 0; ve--) {
+ foundvolume = 1; /* Found the volume on this dump */
foundtape = 0;
- tapeseq = volumeEntries[ve].tapeSeq;
+ tapeseq = volumeEntries[ve].tapeSeq;
- /* Determine where in the list of tapes this should go */
- for (; tle; ptle=tle, tle=tle->next)
- {
- tid = (tle->initialDumpID ? tle->initialDumpID : tle->dumpID);
+ /* Determine where in the list of tapes this should go */
+ for (; tle; ptle = tle, tle = tle->next) {
+ tid =
+ (tle->initialDumpID ? tle->
+ initialDumpID : tle->dumpID);
/* Sort by tapeids. BUT, we don't want add an entry in the middle
* of a dumpset (might split a volume fragmented across tapes).
* incremental was appended to a tape created prior its parent-
* dump's tape, and needs to be restored after it.
*/
- if (tapeid < tid)
- {
- if (tlid != tid)
- { tle = 0; break; } /* Allocate and insert a tape entry */
+ if (tapeid < tid) {
+ if (tlid != tid) {
+ tle = 0;
+ break;
+ } /* Allocate and insert a tape entry */
}
/* Found the tapeid (the dumpset). Check if its the correct
* tape sequence
*/
- else if (tapeid == tid)
- {
- if (tapeseq < tle->tapeNumber)
- { tle = 0; break; } /* Allocate and insert a tape entry */
-
- if (tapeseq == tle->tapeNumber)
- { break; } /* Don't allocate tape entry */
-
- foundtape = 1; /* Found dumpset but not the tape */
+ else if (tapeid == tid) {
+ if (tapeseq < tle->tapeNumber) {
+ tle = 0;
+ break;
+ }
+ /* Allocate and insert a tape entry */
+ if (tapeseq == tle->tapeNumber) {
+ break;
+ }
+ /* Don't allocate tape entry */
+ foundtape = 1; /* Found dumpset but not the tape */
}
/* Prevously found the tapeid (the dumpset) but this tape
* sequence not included (the tapeid has changed). So add
* this tape entry to the end of its dumpset.
*/
- else if (foundtape)
- { tle = 0; break; } /* Allocate and insert a tape entry */
-
+ else if (foundtape) {
+ tle = 0;
+ break;
+ }
+ /* Allocate and insert a tape entry */
}
/* Allocate a new tapelist entry if one not found */
- if (!tle)
- {
- tle = (struct bc_tapeList *) malloc(sizeof(struct bc_tapeList));
- if (!tle)
- {
- com_err(whoami,BC_NOMEM,"");
- return(BC_NOMEM);
+ if (!tle) {
+ tle = (struct bc_tapeList *)
+ malloc(sizeof(struct bc_tapeList));
+ if (!tle) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ return (BC_NOMEM);
}
- bzero(tle, sizeof(struct bc_tapeList));
-
- tle->tapeName = (char*)malloc(strlen(volumeEntries[ve].tape)+1);
- if (!tle->tapeName)
- {
- free(tle);
- com_err(whoami,BC_NOMEM,"");
- return(BC_NOMEM);
+ memset(tle, 0, sizeof(struct bc_tapeList));
+
+ tle->tapeName =
+ (char *)malloc(strlen(volumeEntries[ve].tape)
+ + 1);
+ if (!tle->tapeName) {
+ free(tle);
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ return (BC_NOMEM);
}
strcpy(tle->tapeName, volumeEntries[ve].tape);
- tle->dumpID = dlevels[lv].DumpId;
+ tle->dumpID = dlevels[lv].DumpId;
tle->initialDumpID = dlevels[lv].initialDumpId;
- tle->tapeNumber = tapeseq;
+ tle->tapeNumber = tapeseq;
/* Now thread the tape onto the list */
- if (!ptle)
- {
- tle->next = tapeList;
+ if (!ptle) {
+ tle->next = tapeList;
tapeList = tle;
- }
- else
- {
- tle->next = ptle->next;
+ } else {
+ tle->next = ptle->next;
ptle->next = tle;
}
}
- tlid = (tle->initialDumpID ? tle->initialDumpID : tle->dumpID);
+ tlid =
+ (tle->initialDumpID ? tle->initialDumpID : tle->
+ dumpID);
/* Now place the volume fragment into the correct position on
* this tapelist entry. Duplicate entries are ignored.
*/
- for (pti = 0, ti=tle->restoreList; ti; pti=ti, ti=ti->next)
- {
- if (volumeEntries[ve].position < ti->position)
- { ti = 0; break; } /* Allocate an entry */
-
- else if (volumeEntries[ve].position == ti->position)
- { break; } /* Duplicate entry */
+ for (pti = 0, ti = tle->restoreList; ti;
+ pti = ti, ti = ti->next) {
+ if (volumeEntries[ve].position < ti->position) {
+ ti = 0;
+ break;
+ }
+ /* Allocate an entry */
+ else if (volumeEntries[ve].position ==
+ ti->position) {
+ break;
+ } /* Duplicate entry */
}
/* If didn't find one, allocate and thread onto list.
* Remember the server and partition.
*/
- if (!ti)
- {
- ti = (struct bc_tapeItem *) malloc(sizeof(struct bc_tapeItem));
- if (!ti)
- {
- com_err(whoami,BC_NOMEM,"");
- return(BC_NOMEM);
+ if (!ti) {
+ ti = (struct bc_tapeItem *)
+ malloc(sizeof(struct bc_tapeItem));
+ if (!ti) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ return (BC_NOMEM);
}
- bzero(ti, sizeof(struct bc_tapeItem));
-
- ti->volumeName = (char*)malloc(strlen(volumeEntries[ve].name)+1);
- if (!ti->volumeName)
- {
- free(ti);
- com_err(whoami,BC_NOMEM,"");
- return(BC_NOMEM);
+ memset(ti, 0, sizeof(struct bc_tapeItem));
+
+ ti->volumeName =
+ (char *)malloc(strlen(volumeEntries[ve].name)
+ + 1);
+ if (!ti->volumeName) {
+ free(ti);
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ return (BC_NOMEM);
}
strcpy(ti->volumeName, volumeEntries[ve].name);
- ti->server = vi->server;
+ ti->server = vi->server;
ti->partition = vi->partition;
- ti->oid = volumeEntries[ve].id;
- ti->position = volumeEntries[ve].position;
- ti->vollevel = voldumplevel;
+ ti->oid = volumeEntries[ve].id;
+ ti->position = volumeEntries[ve].position;
+ ti->vollevel = voldumplevel;
ti->dumplevel = dlevels[lv].level;
- ti->lastdump = ((lv == 0) ? 1 : 0);
+ ti->lastdump = ((lv == 0) ? 1 : 0);
- if (!pti)
- {
- ti->next = tle->restoreList;
- tle->restoreList = ti;
- }
- else
- {
- ti->next = pti->next;
+ if (!pti) {
+ ti->next = tle->restoreList;
+ tle->restoreList = ti;
+ } else {
+ ti->next = pti->next;
pti->next = ti;
}
nentries++;
- } /* !ti */
- } /* ve: for each returned volume fragment by bcdb_FindVolumes() */
- } /* last: Multiple calls to bcdb_FindVolumes() */
-
- if (foundvolume) voldumplevel++;
- } /* lv: For each dump level */
- } /* vi: For each volume to search for in the dump hierarchy */
- } /* di: For each dump */
-
- if (!nentries)
- {
- com_err(whoami, 0, "No volumes to restore");
+ } /* !ti */
+ } /* ve: for each returned volume fragment by bcdb_FindVolumes() */
+ } /* last: Multiple calls to bcdb_FindVolumes() */
+
+ if (foundvolume)
+ voldumplevel++;
+ } /* lv: For each dump level */
+ } /* vi: For each volume to search for in the dump hierarchy */
+ } /* di: For each dump */
+
+ if (!nentries) {
+ afs_com_err(whoami, 0, "No volumes to restore");
ERROR(0);
}
- if (dumpTaskPtr->dontExecute)
- {
- for (tle=tapeList; tle; tle=tle->next)
- {
- for (ti=tle->restoreList; ti; ti=ti->next)
- {
- tapedumpid = (tle->initialDumpID ? tle->initialDumpID : tle->dumpID);
+ if (dumpTaskPtr->dontExecute) {
+ for (tle = tapeList; tle; tle = tle->next) {
+ for (ti = tle->restoreList; ti; ti = ti->next) {
+ tapedumpid =
+ (tle->initialDumpID ? tle->initialDumpID : tle->dumpID);
strcpy(vname, ti->volumeName);
StripBackup(vname);
- if (dumpTaskPtr->newExt) strcat(vname, dumpTaskPtr->newExt);
+ if (dumpTaskPtr->newExt)
+ strcat(vname, dumpTaskPtr->newExt);
/* print volume to restore and the tape and position its on */
- if (serverAll)
- {
- printf("Restore volume %s (ID %d) from tape %s (%u), position %d",
- ti->volumeName, ti->oid, tle->tapeName, tapedumpid, ti->position);
+ if (serverAll) {
+ printf
+ ("Restore volume %s (ID %d) from tape %s (%u), position %d",
+ ti->volumeName, ti->oid, tle->tapeName, tapedumpid,
+ ti->position);
if (strcmp(ti->volumeName, vname) != 0)
- printf(" as %s", vname);
+ printf(" as %s", vname);
printf(".\n");
}
/* print in format recognized by volsetrestore */
- else
- {
+ else {
haddr = ti->server;
- hostPtr = gethostbyaddr((char *) &haddr, sizeof(haddr), AF_INET);
- if (hostPtr) printf("%s", hostPtr->h_name);
- else printf("%u", ti->server);
-
+ hostPtr =
+ gethostbyaddr((char *)&haddr, sizeof(haddr), AF_INET);
+ if (hostPtr)
+ printf("%s", hostPtr->h_name);
+ else
+ printf("%u", ti->server);
+
printf(" /vicep");
viceName(ti->partition);
- printf(" %s # as %s; %s (%u); pos %d;",
- ti->volumeName, vname, tle->tapeName, tapedumpid, ti->position);
-
+ printf(" %s # as %s; %s (%u); pos %d;", ti->volumeName,
+ vname, tle->tapeName, tapedumpid, ti->position);
+
did = tle->dumpID;
printf(" %s", ctime(&did));
}
}
/* Allocate a list of volumes to restore */
- tcarray = (struct tc_restoreDesc *) malloc(nentries*sizeof(struct tc_restoreDesc));
- if (!tcarray)
- {
- com_err(whoami,BC_NOMEM,"");
+ tcarray =
+ (struct tc_restoreDesc *)malloc(nentries *
+ sizeof(struct tc_restoreDesc));
+ if (!tcarray) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
ERROR(BC_NOMEM);
}
- bzero(tcarray, nentries*sizeof(struct tc_restoreDesc));
+ memset(tcarray, 0, nentries * sizeof(struct tc_restoreDesc));
/* Fill in the array with the list above */
i = 0;
- for (tle=tapeList; tle; tle=tle->next)
- {
- for (ti=tle->restoreList; ti; ti=ti->next)
- {
- tcarray[i].origVid = ti->oid; /* means unknown */
- tcarray[i].vid = 0;
- tcarray[i].flags = 0;
+ for (tle = tapeList; tle; tle = tle->next) {
+ for (ti = tle->restoreList; ti; ti = ti->next) {
+ tcarray[i].origVid = ti->oid; /* means unknown */
+ tcarray[i].vid = 0;
+ tcarray[i].flags = 0;
if (ti->vollevel == 0)
- tcarray[i].flags |= RDFLAG_FIRSTDUMP;
+ tcarray[i].flags |= RDFLAG_FIRSTDUMP;
if (ti->lastdump)
- tcarray[i].flags |= RDFLAG_LASTDUMP;
- tcarray[i].position = ti->position;
- tcarray[i].dbDumpId = tle->dumpID;
+ tcarray[i].flags |= RDFLAG_LASTDUMP;
+ tcarray[i].position = ti->position;
+ tcarray[i].dbDumpId = tle->dumpID;
tcarray[i].initialDumpId = tle->initialDumpID;
- tcarray[i].hostAddr = ti->server; /* just the internet address */
- tcarray[i].partition = ti->partition;
+ tcarray[i].hostAddr = ti->server; /* just the internet address */
+ tcarray[i].partition = ti->partition;
strcpy(tcarray[i].tapeName, tle->tapeName);
- strcpy(tcarray[i].oldName, ti->volumeName);
- strcpy(tcarray[i].newName, ti->volumeName);
+ strcpy(tcarray[i].oldName, ti->volumeName);
+ strcpy(tcarray[i].newName, ti->volumeName);
StripBackup(tcarray[i].newName);
- if (dumpTaskPtr->newExt) strcat(tcarray[i].newName, dumpTaskPtr->newExt);
+ if (dumpTaskPtr->newExt)
+ strcat(tcarray[i].newName, dumpTaskPtr->newExt);
- tcarray[i].dumpLevel = ti->dumplevel;
+ tcarray[i].dumpLevel = ti->dumplevel;
i++;
}
}
printf("Starting restore\n");
/* Loop until all of the tape entries are used */
- for (startentry=0; startentry<nentries; startentry+=todump)
- {
+ for (startentry = 0; startentry < nentries; startentry += todump) {
/* Get all the next tape entries with the same port offset */
- if (dumpTaskPtr->portCount == 0)
- {
- port = 0;
+ if (dumpTaskPtr->portCount == 0) {
+ port = 0;
todump = nentries - startentry;
- }
- else if (dumpTaskPtr->portCount == 1)
- {
- port = dumpTaskPtr->portOffset[0];
+ } else if (dumpTaskPtr->portCount == 1) {
+ port = dumpTaskPtr->portOffset[0];
todump = nentries - startentry;
- }
- else
- {
+ } else {
level = tcarray[startentry].dumpLevel;
- port = dumpTaskPtr->portOffset[(level <= dumpTaskPtr->portCount-1 ?
- level : dumpTaskPtr->portCount-1)];
-
- for (todump=1; ((startentry+todump) < nentries); todump++)
- {
- level = tcarray[startentry+todump].dumpLevel;
- nextport = dumpTaskPtr->portOffset[(level <= dumpTaskPtr->portCount-1 ?
- level : dumpTaskPtr->portCount-1)];
- if (port != nextport) break; /* break if we change ports */
+ port =
+ dumpTaskPtr->
+ portOffset[(level <=
+ dumpTaskPtr->portCount -
+ 1 ? level : dumpTaskPtr->portCount - 1)];
+
+ for (todump = 1; ((startentry + todump) < nentries); todump++) {
+ level = tcarray[startentry + todump].dumpLevel;
+ nextport =
+ dumpTaskPtr->
+ portOffset[(level <=
+ dumpTaskPtr->portCount -
+ 1 ? level : dumpTaskPtr->portCount - 1)];
+ if (port != nextport)
+ break; /* break if we change ports */
}
}
rpcArray.tc_restoreArray_val = &tcarray[startentry];
code = ConnectButc(dumpTaskPtr->config, port, &aconn);
- if (code) return(code);
-
+ if (code)
+ return (code);
+
if (tcarray[startentry].dumpLevel == 0)
printf("\nFull restore being processed on port %d\n", port);
else
- printf("\nIncremental restore being processed on port %d\n", port);
-
- code = TC_PerformRestore(aconn, "DumpSetName", &rpcArray, &dumpTaskPtr->dumpID);
- if (code)
- {
- com_err(whoami,code,"; Failed to start restore");
+ printf("\nIncremental restore being processed on port %d\n",
+ port);
+
+ code =
+ TC_PerformRestore(aconn, "DumpSetName", &rpcArray,
+ &dumpTaskPtr->dumpID);
+ if (code) {
+ afs_com_err(whoami, code, "; Failed to start restore");
break;
}
/* setup status monitor node */
statusPtr = createStatusNode();
lock_Status();
- statusPtr->port = port;
- statusPtr->taskId = dumpTaskPtr->dumpID;
- statusPtr->jobNumber = bc_jobNumber();
- statusPtr->flags &= ~STARTING; /* clearStatus to examine */
+ statusPtr->port = port;
+ statusPtr->taskId = dumpTaskPtr->dumpID;
+ statusPtr->jobNumber = bc_jobNumber();
+ statusPtr->flags &= ~STARTING; /* clearStatus to examine */
if (tcarray[startentry].dumpLevel == 0)
sprintf(statusPtr->taskName, "Full Restore");
else
/* Wait until this restore pass is complete before starting the next
* pass. Query the statusWatcher for the status
*/
- while (1)
- {
+ while (1) {
lock_Status();
newStatusPtr = findStatus(dumpTaskPtr->dumpID);
- if (!newStatusPtr || (newStatusPtr->flags &
- (ABORT_REQUEST|ABORT_SENT|ABORT_DONE|TASK_ERROR)) )
- {
- unlock_Status();
+ if (!newStatusPtr
+ || (newStatusPtr->
+ flags & (ABORT_REQUEST | ABORT_SENT | ABORT_DONE |
+ TASK_ERROR))) {
+ unlock_Status();
ERROR(0);
- }
- else if (newStatusPtr->flags & (TASK_DONE))
- {
+ } else if (newStatusPtr->flags & (TASK_DONE)) {
unlock_Status();
break;
}
IOMGR_Sleep(2);
}
- if (aconn) rx_DestroyConnection(aconn);
+ if (aconn)
+ rx_DestroyConnection(aconn);
aconn = (struct rx_connection *)0;
- } /* while */
+ } /* while */
/* free up everything */
error_exit:
- if (aconn) rx_DestroyConnection(aconn);
+ if (aconn)
+ rx_DestroyConnection(aconn);
- if (tcarray) free(tcarray);
+ if (tcarray)
+ free(tcarray);
/* Free the dumpinfo list and its volumes */
- for (di=dumpinfolist; di; di=ndi)
- {
- for (vi=di->volinfolist; vi; vi=nvi)
- {
- if (vi->volname) free(vi->volname);
+ for (di = dumpinfolist; di; di = ndi) {
+ for (vi = di->volinfolist; vi; vi = nvi) {
+ if (vi->volname)
+ free(vi->volname);
nvi = vi->next;
free(vi);
}
- ndi = di->next;
+ ndi = di->next;
free(di);
}
/* Free the tape lists and items */
- for (tle = tapeList; tle; tle=ntle)
- {
- for(ti = tle->restoreList; ti; ti = nti)
- {
+ for (tle = tapeList; tle; tle = ntle) {
+ for (ti = tle->restoreList; ti; ti = nti) {
nti = ti->next;
- if (ti->volumeName) free(ti->volumeName);
+ if (ti->volumeName)
+ free(ti->volumeName);
free(ti);
}
ntle = tle->next;
- if (tle->tapeName) free(tle->tapeName);
+ if (tle->tapeName)
+ free(tle->tapeName);
free(tle);
}
/* free local-like things we alloacted to save stack space */
- if (volumeEntries) free(volumeEntries);
+ if (volumeEntries)
+ free(volumeEntries);
+
+ free(dlevels);
return code;
}
git://git.openafs.org / openafs.git / blobdiff