/*
* 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
#include <afsconfig.h>
#include <afs/param.h>
+#include <afs/stds.h>
-RCSID("$Header$");
+#include <roken.h>
-#include <afs/stds.h>
-#include <sys/types.h>
-#include <afs/cmd.h>
-#ifdef AFS_NT40_ENV
-#include <winsock2.h>
-#else
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netdb.h>
-#include <strings.h>
+#ifdef HAVE_POSIX_REGEX /* use POSIX regexp library */
+#include <regex.h>
#endif
-#include <errno.h>
+
+#include <afs/cmd.h>
#include <afs/com_err.h>
+#include <afs/afsutil.h>
#include <afs/budb.h>
+#include <afs/budb_prototypes.h>
#include <afs/butc.h>
#include <afs/bubasics.h> /* PA */
#include <afs/volser.h>
#include <afs/voldefs.h> /* PA */
#include <afs/vldbint.h> /* PA */
#include <afs/ktime.h> /* PA */
-#include <time.h>
-
-#include <string.h>
+#include <ubik.h>
#include <lock.h>
-#include <afs/butc.h>
#include <afs/tcdata.h>
#include <afs/butx.h>
+#include <afs/vsutils_prototypes.h>
+
#include "bc.h"
#include "error_macros.h"
-
+#include "bucoord_internal.h"
+#include "bucoord_prototypes.h"
extern struct bc_config *bc_globalConfig;
-extern char *ktime_GetDateUsage();
-extern struct bc_dumpSchedule *bc_FindDumpSchedule();
-extern struct bc_volumeSet *bc_FindVolumeSet(struct bc_config *cfg, char *name);
extern struct bc_dumpTask bc_dumpTasks[BC_MAXSIMDUMPS];
extern struct ubik_client *cstruct;
-extern int bc_Dumper(); /* function to do dumps */
-extern int bc_Restorer(); /* function to do restores */
-extern void bc_HandleMisc();
-extern afs_int32 ScanDumpHdr();
-extern afs_int32 ScanTapeVolume();
extern char *whoami;
-extern int VL_ListEntry();
-extern int VL_ListAttributesN2();
-extern struct ktc_token ttoken;
-extern char *tailCompPtr();
-extern statusP createStatusNode();
char *loadFile;
extern afs_int32 lastTaskCode;
-#ifdef AFS_DEC_ENV
-#define HOSTADDR(sockaddr) (sockaddr)->sin_addr.S_un.S_addr
-#else
#define HOSTADDR(sockaddr) (sockaddr)->sin_addr.s_addr
-#endif
-int bc_EvalVolumeSet(aconfig, avs, avols, uclient)
- struct bc_config *aconfig;
- register struct bc_volumeSet *avs;
- struct bc_volumeDump **avols;
- struct ubik_client *uclient;
-{ /*bc_EvalVolumeSet*/
- int code;
- int a,b,c;
- static afs_int32 use=2;
-
- if (use == 2) { /* Use EvalVolumeSet2() */
- code = EvalVolumeSet2(aconfig, avs, avols, uclient);
- if (code == RXGEN_OPCODE) use = 1;
- }
- if (use == 1) { /* Use EvalVolumeSet1() */
- code = EvalVolumeSet1(aconfig, avs, avols, uclient);
- }
- return code;
-} /*bc_EvalVolumeSet*/
+static int EvalVolumeSet1(struct bc_config *aconfig, struct bc_volumeSet *avs,
+ struct bc_volumeDump **avols,
+ struct ubik_client *uclient);
+
+static int EvalVolumeSet2(struct bc_config *aconfig, struct bc_volumeSet *avs,
+ struct bc_volumeDump **avols,
+ struct ubik_client *uclient);
+static int DBLookupByVolume(char *volumeName);
+
+int
+bc_EvalVolumeSet(struct bc_config *aconfig,
+ struct bc_volumeSet *avs,
+ struct bc_volumeDump **avols,
+ struct ubik_client *uclient)
+{ /*bc_EvalVolumeSet */
+ int code = -1;
+ static afs_int32 use = 2;
+
+ if (use == 2) { /* Use EvalVolumeSet2() */
+ code = EvalVolumeSet2(aconfig, avs, avols, uclient);
+ if (code == RXGEN_OPCODE)
+ use = 1;
+ }
+ if (use == 1) { /* Use EvalVolumeSet1() */
+ code = EvalVolumeSet1(aconfig, avs, avols, uclient);
+ }
+ return code;
+} /*bc_EvalVolumeSet */
struct partitionsort {
- afs_int32 part;
- struct bc_volumeDump *vdlist;
- struct bc_volumeDump *lastvdlist;
- struct bc_volumeDump *dupvdlist;
- struct bc_volumeEntry *vole;
- struct partitionsort *next;
+ afs_int32 part;
+ struct bc_volumeDump *vdlist;
+ struct bc_volumeDump *lastvdlist;
+ struct bc_volumeDump *dupvdlist;
+ struct bc_volumeEntry *vole;
+ struct partitionsort *next;
};
struct serversort {
- afs_uint32 ipaddr;
- struct partitionsort *partitions;
- struct serversort *next;
+ afs_uint32 ipaddr;
+ struct partitionsort *partitions;
+ struct serversort *next;
};
-afs_int32 getSPEntries(server, partition, serverlist, ss, ps)
- afs_uint32 server;
- afs_int32 partition;
- struct serversort **serverlist, **ss;
- struct partitionsort **ps;
+afs_int32
+getSPEntries(afs_uint32 server, afs_int32 partition,
+ struct serversort **serverlist,
+ struct serversort **ss,
+ struct partitionsort **ps)
{
- if (!(*ss) || ((*ss)->ipaddr != server)) {
- *ps = 0;
- for ((*ss)=*serverlist; (*ss); *ss=(*ss)->next) {
- if ((*ss)->ipaddr == server)
- break;
- }
- }
- /* No server entry added. Add one */
- if (!(*ss)) {
- *ss = (struct serversort *) malloc(sizeof(struct serversort));
- if (!(*ss)) {
- com_err(whoami, BC_NOMEM, "");
- *ss = 0;
- return(BC_NOMEM);
- }
- memset(*ss, 0, sizeof(struct serversort));
- (*ss)->ipaddr = server;
- (*ss)->next = *serverlist;
- *serverlist = *ss;
- }
+ if (!(*ss) || ((*ss)->ipaddr != server)) {
+ *ps = 0;
+ for ((*ss) = *serverlist; (*ss); *ss = (*ss)->next) {
+ if ((*ss)->ipaddr == server)
+ break;
+ }
+ }
+ /* No server entry added. Add one */
+ if (!(*ss)) {
+ *ss = (struct serversort *)malloc(sizeof(struct serversort));
+ if (!(*ss)) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ *ss = 0;
+ return (BC_NOMEM);
+ }
+ memset(*ss, 0, sizeof(struct serversort));
+ (*ss)->ipaddr = server;
+ (*ss)->next = *serverlist;
+ *serverlist = *ss;
+ }
- if (!(*ps) || ((*ps)->part != partition)) {
- for (*ps=(*ss)->partitions; *ps; *ps=(*ps)->next) {
- if ((*ps)->part == partition)
- break;
- }
- }
- /* No partition entry added. Add one */
- if (!(*ps)) {
- *ps = (struct partitionsort *) malloc(sizeof(struct partitionsort));
- if (!(*ps)) {
- com_err(whoami, BC_NOMEM, "");
- free (*ss);
- *ps = 0;
- *ss = 0;
- return(BC_NOMEM);
- }
- memset(*ps, 0, sizeof(struct partitionsort));
- (*ps)->part = partition;
- (*ps)->next = (*ss)->partitions;
- (*ss)->partitions = *ps;
- }
- return 0;
+ if (!(*ps) || ((*ps)->part != partition)) {
+ for (*ps = (*ss)->partitions; *ps; *ps = (*ps)->next) {
+ if ((*ps)->part == partition)
+ break;
+ }
+ }
+ /* No partition entry added. Add one */
+ if (!(*ps)) {
+ *ps = (struct partitionsort *)malloc(sizeof(struct partitionsort));
+ if (!(*ps)) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ free(*ss);
+ *ps = 0;
+ *ss = 0;
+ return (BC_NOMEM);
+ }
+ memset(*ps, 0, sizeof(struct partitionsort));
+ (*ps)->part = partition;
+ (*ps)->next = (*ss)->partitions;
+ (*ss)->partitions = *ps;
+ }
+ return 0;
}
-afs_int32 randSPEntries(serverlist, avols)
- struct serversort *serverlist;
- struct bc_volumeDump **avols;
+afs_int32
+randSPEntries(struct serversort *serverlist,
+ struct bc_volumeDump **avols)
{
- struct serversort *ss, **pss, *tss;
- struct partitionsort *ps, **pps;
- afs_int32 r;
- afs_int32 scount, pcount;
-
- *avols = 0;
-
- /* Seed random number generator */
- r = time(0) + getpid();
- srand(r);
-
- /* Count number of servers, remove one at a time */
- for (scount=0, ss=serverlist; ss; ss=ss->next, scount++);
- for (; scount; scount--) {
- /* Pick a random server in list and remove it */
- r = (rand()>>4) % scount;
- for (pss=&serverlist, ss=serverlist; r;
- pss=&ss->next, ss=ss->next, r--);
- *pss = ss->next;
-
- /* Count number of partitions, remove one at a time */
- for (pcount=0, ps=ss->partitions; ps; ps=ps->next, pcount++);
- for (; pcount; pcount--) {
- /* Pick a random parition in list and remove it */
- r = (rand()>>4) % pcount;
- for (pps=&ss->partitions, ps=ss->partitions; r;
- pps=&ps->next, ps=ps->next, r--);
- *pps = ps->next;
-
- ps->lastvdlist->next = *avols;
- *avols = ps->vdlist;
- free(ps);
- }
- free(ss);
- }
+ struct serversort *ss, **pss;
+ struct partitionsort *ps, **pps;
+ afs_int32 r;
+ afs_int32 scount, pcount;
+
+ *avols = 0;
+
+ /* Seed random number generator */
+ r = time(0) + getpid();
+ srand(r);
+
+ /* Count number of servers, remove one at a time */
+ for (scount = 0, ss = serverlist; ss; ss = ss->next, scount++);
+ for (; scount; scount--) {
+ /* Pick a random server in list and remove it */
+ r = (rand() >> 4) % scount;
+ for (pss = &serverlist, ss = serverlist; r;
+ pss = &ss->next, ss = ss->next, r--);
+ *pss = ss->next;
+
+ /* Count number of partitions, remove one at a time */
+ for (pcount = 0, ps = ss->partitions; ps; ps = ps->next, pcount++);
+ for (; pcount; pcount--) {
+ /* Pick a random parition in list and remove it */
+ r = (rand() >> 4) % pcount;
+ for (pps = &ss->partitions, ps = ss->partitions; r;
+ pps = &ps->next, ps = ps->next, r--);
+ *pps = ps->next;
+
+ ps->lastvdlist->next = *avols;
+ *avols = ps->vdlist;
+ free(ps);
+ }
+ free(ss);
+ }
+ return 0;
}
-int EvalVolumeSet2(aconfig, avs, avols, uclient)
- struct bc_config *aconfig;
- struct bc_volumeSet *avs;
- struct bc_volumeDump **avols;
- struct ubik_client *uclient;
-{ /*EvalVolumeSet2*/
- struct bc_volumeEntry *tve;
- struct bc_volumeDump *tavols;
- struct VldbListByAttributes attributes;
- afs_int32 si, nsi; /* startIndex and nextStartIndex */
- afs_int32 nentries, e, ei, et, add, l;
- nbulkentries bulkentries;
- struct nvldbentry *entries=0;
- struct bc_volumeDump *tvd;
- afs_int32 code=0, tcode;
- afs_int32 count=0;
- struct serversort *servers=0, *lastserver=0, *ss=0, *nss;
- struct partitionsort *ps=0, *nps;
-
- *avols = (struct bc_volumeDump *) 0;
- bulkentries.nbulkentries_len = 0;
- bulkentries.nbulkentries_val = 0;
-
- /* For each of the volume set entries - collect the volumes that match it */
- for (tve=avs->ventries; tve; tve=tve->next) {
- /* Put together a call to the vlserver for this vlentry. The
- * performance gain is from letting the vlserver expand the
- * volumeset and not this routine.
- */
- attributes.Mask = 0;
- if (tve->server.sin_addr.s_addr) { /* The server */
- attributes.Mask |= VLLIST_SERVER;
- attributes.server = tve->server.sin_addr.s_addr;
- }
- if (tve->partition != -1) { /* The partition */
- attributes.Mask |= VLLIST_PARTITION;
- attributes.partition = tve->partition;
- }
-
- /* Now make the call to the vlserver */
- for (si=0; si != -1; si=nsi) {
- nentries = 0;
- bulkentries.nbulkentries_len = 0;
- bulkentries.nbulkentries_val = 0;
- nsi = -1;
- tcode = ubik_Call(VL_ListAttributesN2, uclient, 0,
- &attributes, tve->name, si,
- &nentries, &bulkentries, &nsi);
- if (tcode) ERROR(tcode);
-
- /* The 3.4 vlserver has a VL_ListAttributesN2() RPC call, but
- * it is not complete. The only way to tell if it is not complete
- * is if et == 0 (which we check for below). Also, if the call didn't
- * match any entries, then we don't know what version the vlserver
- * is. In both cases, we return RXGEN_OPCODE and the calling routine
- * will switch to the EvalVolumeSet1() call.
+static int
+EvalVolumeSet2(struct bc_config *aconfig,
+ struct bc_volumeSet *avs,
+ struct bc_volumeDump **avols,
+ struct ubik_client *uclient)
+{ /*EvalVolumeSet2 */
+ struct bc_volumeEntry *tve;
+ struct bc_volumeDump *tavols;
+ struct VldbListByAttributes attributes;
+ afs_int32 si, nsi; /* startIndex and nextStartIndex */
+ afs_int32 nentries, e, ei, et, add, l;
+ nbulkentries bulkentries;
+ struct nvldbentry *entries = 0;
+ struct bc_volumeDump *tvd;
+ afs_int32 code = 0, tcode;
+ afs_int32 count = 0;
+ struct serversort *servers = 0, *ss = 0;
+ struct partitionsort *ps = 0;
+
+ *avols = (struct bc_volumeDump *)0;
+ bulkentries.nbulkentries_len = 0;
+ bulkentries.nbulkentries_val = 0;
+
+ /* For each of the volume set entries - collect the volumes that match it */
+ for (tve = avs->ventries; tve; tve = tve->next) {
+ /* Put together a call to the vlserver for this vlentry. The
+ * performance gain is from letting the vlserver expand the
+ * volumeset and not this routine.
*/
- if (nentries == 0) ERROR(RXGEN_OPCODE); /* Use EvalVolumeSet1 */
-
- /* Step through each entry and add it to the list of volumes */
- entries = bulkentries.nbulkentries_val;
- for (e=0; e<nentries; e++) {
- ei = entries[e].matchindex & 0xffff;
- et = (entries[e].matchindex >> 16) & 0xffff;
- switch (et) {
- case ITSRWVOL: {et = RWVOL; break;}
- case ITSBACKVOL:{et = BACKVOL; break;}
- case ITSROVOL: {et = ROVOL; break;}
- default: ERROR(RXGEN_OPCODE); /* Use EvalVolumeSet1 */
- }
-
- /* Find server and partiton structure to hang the entry off of */
- tcode = getSPEntries(entries[e].serverNumber[ei],
- entries[e].serverPartition[ei],
- &servers, &ss, &ps);
- if (tcode) {
- com_err(whoami, tcode, "");
- ERROR(tcode);
- }
-
- /* Detect if this entry should be added (not a duplicate).
- * Use ps->dupvdlist and ps->vole to only search volumes from
- * previous volume set entries.
- */
- add = 1;
- if (tve != avs->ventries) {
- l = strlen(entries[e].name);
- if (ps->vole != tve) {
- ps->vole = tve;
- ps->dupvdlist = ps->vdlist;
- }
- for (tavols=ps->dupvdlist; add && tavols; tavols=tavols->next) {
- if (strncmp(tavols->name, entries[e].name, l) == 0) {
- if ( (strcmp(&entries[e].name[l], ".backup") == 0) ||
- (strcmp(&entries[e].name[l], ".readonly") == 0) ||
- (strcmp(&entries[e].name[l], "") == 0) )
- add = 0;
- }
- }
- }
-
- if (add) {
- /* Allocate a volume dump structure and its name */
- tvd = (struct bc_volumeDump *) malloc(sizeof(struct bc_volumeDump));
- if (!tvd) {
- com_err(whoami, BC_NOMEM, "");
- ERROR(BC_NOMEM);
- }
- memset(tvd, 0, sizeof(*tvd));
-
- tvd->name = (char *) malloc(strlen(entries[e].name)+10);
- if (!(tvd->name)) {
- com_err(whoami, BC_NOMEM, "");
- free(tvd);
- ERROR(BC_NOMEM);
- }
-
- /* Fill it in and thread onto avols list */
- strcpy(tvd->name, entries[e].name);
- if (et == BACKVOL) strcat(tvd->name, ".backup");
- else if (et == ROVOL) strcat(tvd->name, ".readonly");
- tvd->vid = entries[e].volumeId[et];
- tvd->entry = tve;
- tvd->volType = et;
- tvd->partition = entries[e].serverPartition[ei];
- tvd->server.sin_addr.s_addr = entries[e].serverNumber[ei];
- tvd->server.sin_port = 0; /* default FS port */
- tvd->server.sin_family = AF_INET;
+ attributes.Mask = 0;
+ if (tve->server.sin_addr.s_addr) { /* The server */
+ attributes.Mask |= VLLIST_SERVER;
+ attributes.server = tve->server.sin_addr.s_addr;
+ }
+ if (tve->partition != -1) { /* The partition */
+ attributes.Mask |= VLLIST_PARTITION;
+ attributes.partition = tve->partition;
+ }
+
+ /* Now make the call to the vlserver */
+ for (si = 0; si != -1; si = nsi) {
+ nentries = 0;
+ bulkentries.nbulkentries_len = 0;
+ bulkentries.nbulkentries_val = 0;
+ nsi = -1;
+ tcode =
+ ubik_VL_ListAttributesN2(uclient, 0, &attributes,
+ tve->name, si, &nentries, &bulkentries, &nsi);
+ if (tcode)
+ ERROR(tcode);
+
+ /* The 3.4 vlserver has a VL_ListAttributesN2() RPC call, but
+ * it is not complete. The only way to tell if it is not complete
+ * is if et == 0 (which we check for below). Also, if the call didn't
+ * match any entries, then we don't know what version the vlserver
+ * is. In both cases, we return RXGEN_OPCODE and the calling routine
+ * will switch to the EvalVolumeSet1() call.
+ */
+ if (nentries == 0)
+ ERROR(RXGEN_OPCODE); /* Use EvalVolumeSet1 */
+
+ if (nentries < 0)
+ nentries = 0;
+ if (nentries > bulkentries.nbulkentries_len)
+ nentries = bulkentries.nbulkentries_len;
+
+ /* Step through each entry and add it to the list of volumes */
+ entries = bulkentries.nbulkentries_val;
+ for (e = 0; e < nentries; e++) {
+ ei = entries[e].matchindex & 0xffff;
+ et = (entries[e].matchindex >> 16) & 0xffff;
+ switch (et) {
+ case ITSRWVOL:{
+ et = RWVOL;
+ break;
+ }
+ case ITSBACKVOL:{
+ et = BACKVOL;
+ break;
+ }
+ case ITSROVOL:{
+ et = ROVOL;
+ break;
+ }
+ default:
+ ERROR(RXGEN_OPCODE); /* Use EvalVolumeSet1 */
+ }
+
+ /* Find server and partiton structure to hang the entry off of */
+ tcode =
+ getSPEntries(entries[e].serverNumber[ei],
+ entries[e].serverPartition[ei], &servers,
+ &ss, &ps);
+ if (tcode) {
+ afs_com_err(whoami, tcode, NULL);
+ ERROR(tcode);
+ }
+
+ /* Detect if this entry should be added (not a duplicate).
+ * Use ps->dupvdlist and ps->vole to only search volumes from
+ * previous volume set entries.
+ */
+ add = 1;
+ if (tve != avs->ventries) {
+ l = strlen(entries[e].name);
+ if (ps->vole != tve) {
+ ps->vole = tve;
+ ps->dupvdlist = ps->vdlist;
+ }
+ for (tavols = ps->dupvdlist; add && tavols;
+ tavols = tavols->next) {
+ if (strncmp(tavols->name, entries[e].name, l) == 0) {
+ if ((strcmp(&entries[e].name[l], ".backup") == 0)
+ || (strcmp(&entries[e].name[l], ".readonly")
+ == 0)
+ || (strcmp(&entries[e].name[l], "") == 0))
+ add = 0;
+ }
+ }
+ }
+
+ if (add) {
+ /* Allocate a volume dump structure and its name */
+ tvd = (struct bc_volumeDump *)
+ malloc(sizeof(struct bc_volumeDump));
+ if (!tvd) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ ERROR(BC_NOMEM);
+ }
+ memset(tvd, 0, sizeof(*tvd));
+
+ tvd->name = (char *)malloc(strlen(entries[e].name) + 10);
+ if (!(tvd->name)) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ free(tvd);
+ ERROR(BC_NOMEM);
+ }
+
+ /* Fill it in and thread onto avols list */
+ strcpy(tvd->name, entries[e].name);
+ if (et == BACKVOL)
+ strcat(tvd->name, ".backup");
+ else if (et == ROVOL)
+ strcat(tvd->name, ".readonly");
+ tvd->vid = entries[e].volumeId[et];
+ tvd->entry = tve;
+ tvd->volType = et;
+ tvd->partition = entries[e].serverPartition[ei];
+ tvd->server.sin_addr.s_addr = entries[e].serverNumber[ei];
+ tvd->server.sin_port = 0; /* default FS port */
+ tvd->server.sin_family = AF_INET;
#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
- tvd->server.sin_len = sizeof(struct sockaddr_in);
-#endif
-
- /* String tvd off of partition struct */
- tvd->next = ps->vdlist;
- ps->vdlist = tvd;
- if (!tvd->next)
- ps->lastvdlist = tvd;
-
- count++;
- }
- }
-
- /* Free memory allocated during VL call */
- if (bulkentries.nbulkentries_val) {
- free((char *)bulkentries.nbulkentries_val);
- bulkentries.nbulkentries_val = 0;
- entries = 0;
- }
- }
- }
-
- /* Randomly link the volumedump entries together */
- randSPEntries(servers, avols);
- fprintf (stderr, "Total number of volumes : %u\n", count);
-
- error_exit:
- if (bulkentries.nbulkentries_val) {
- free((char *)bulkentries.nbulkentries_val);
- }
- return(code);
-} /*EvalVolumeSet2*/
+ tvd->server.sin_len = sizeof(struct sockaddr_in);
+#endif
+
+ /* String tvd off of partition struct */
+ tvd->next = ps->vdlist;
+ ps->vdlist = tvd;
+ if (!tvd->next)
+ ps->lastvdlist = tvd;
+
+ count++;
+ }
+ }
+
+ /* Free memory allocated during VL call */
+ if (bulkentries.nbulkentries_val) {
+ free((char *)bulkentries.nbulkentries_val);
+ bulkentries.nbulkentries_val = 0;
+ entries = 0;
+ }
+ }
+ }
+
+ /* Randomly link the volumedump entries together */
+ randSPEntries(servers, avols);
+ fprintf(stderr, "Total number of volumes : %u\n", count);
+
+ error_exit:
+ if (bulkentries.nbulkentries_val) {
+ free((char *)bulkentries.nbulkentries_val);
+ }
+ return (code);
+} /*EvalVolumeSet2 */
/*-----------------------------------------------------------------------------
* EvalVolumeSetOld
*
* Description:
- * Takes the entries in a volumeset and expands them into a list of
+ * Takes the entries in a volumeset and expands them into a list of
* volumes. Every VLDB volume entry is looked at and compared to the
* volumeset entries.
*
- * When matching a VLDB volume entry to a volumeset entry,
+ * When matching a VLDB volume entry to a volumeset entry,
* 1. If the RW volume entry matches, that RW volume is used.
* 2. Otherwise, if the BK volume entry matches, the BK volume is used.
* 3. Finally, if the RO volume entry matches, the RO volume is used.
- * For instance: A volumeset entry of ".* .* user.t.*" will match volume
- * "user.troy" and "user.troy.backup". The rules will use
+ * For instance: A volumeset entry of ".* .* user.t.*" will match volume
+ * "user.troy" and "user.troy.backup". The rules will use
* the RW volume "user.troy".
*
* When a VLDB volume entry matches a volumeset entry (be it RW, BK or RO),
- * that volume is used and matches against any remaining volumeset entries
+ * that volume is used and matches against any remaining volumeset entries
* are not even done.
* For instance: A 1st volumeset entry ".* .* .*.backup" will match with
- * "user.troy.backup". Its 2nd volumeset entry ".* .* .*"
- * would have matched its RW volume "user.troy", but the first
+ * "user.troy.backup". Its 2nd volumeset entry ".* .* .*"
+ * would have matched its RW volume "user.troy", but the first
* match is used and the second match isn't even done.
*
* Arguments:
* aconfig : Global configuration info.
- * avs :
+ * avs :
* avols : Ptr to linked list of entries describing volumes to dump.
* uclient : Ptr to Ubik client structure.
*
* None.
*-----------------------------------------------------------------------------
*/
-int EvalVolumeSet1(aconfig, avs, avols, uclient)
- struct bc_config *aconfig;
- struct bc_volumeSet *avs;
- struct bc_volumeDump **avols;
- struct ubik_client *uclient;
-{ /*EvalVolumeSet1*/
- afs_int32 code; /*Result of various calls*/
- char *errm;
- struct bc_volumeDump *tvd; /*Ptr to new dump instance*/
- struct bc_volumeEntry *tve, *ctve; /*Ptr to new volume entry instance*/
- char patt[256]; /*Composite regex; also, target string*/
- int volType; /*Type of volume that worked */
- afs_int32 index; /*Current VLDB entry index*/
- afs_int32 count; /*Needed by VL_ListEntry()*/
- afs_int32 next_index; /*Next index to list*/
- struct vldbentry entry; /*VLDB entry*/
- int srvpartpair; /*Loop counter: server/partition pair*/
+static int
+EvalVolumeSet1(struct bc_config *aconfig,
+ struct bc_volumeSet *avs,
+ struct bc_volumeDump **avols,
+ struct ubik_client *uclient)
+{ /*EvalVolumeSet1 */
+ afs_int32 code; /*Result of various calls */
+ struct bc_volumeDump *tvd; /*Ptr to new dump instance */
+ struct bc_volumeEntry *tve, *ctve; /*Ptr to new volume entry instance */
+ char patt[256]; /*Composite regex; also, target string */
+ int volType = 0; /*Type of volume that worked */
+ afs_int32 index; /*Current VLDB entry index */
+ afs_int32 count; /*Needed by VL_ListEntry() */
+ afs_int32 next_index; /*Next index to list */
+ struct vldbentry entry; /*VLDB entry */
+ int srvpartpair; /*Loop counter: server/partition pair */
afs_int32 total = 0;
- int found, foundentry;
- struct serversort *servers=0, *ss=0;
- struct partitionsort *ps=0;
+ int found;
+ int foundentry = 0;
+ struct serversort *servers = 0, *ss = 0;
+ struct partitionsort *ps = 0;
+#ifdef HAVE_POSIX_REGEX
+ regex_t re;
+ int need_regfree = 0;
+#else
+ char *errm;
+#endif
- *avols = (struct bc_volumeDump *) 0;
- ctve = (struct bc_volumeEntry *) 0; /* no compiled entry */
+ *avols = (struct bc_volumeDump *)0;
+ ctve = (struct bc_volumeEntry *)0; /* no compiled entry */
/* For each vldb entry.
* Variable next_index is set to the index of the next VLDB entry
* in the enumeration.
*/
- for (index=0; 1; index=next_index)
- { /*w*/
+ for (index = 0; 1; index = next_index) { /*w */
memset(&entry, 0, sizeof(entry));
- code = ubik_Call(VL_ListEntry, /*Routine to invoke*/
- uclient, /*Ubik client structure*/
- 0, /*Ubik flags*/
- index, /*Current index*/
- &count, /*Ptr to working variable*/
- &next_index, /*Ptr to next index value to list*/
- &entry); /*Ptr to entry to fill*/
- if (code) return code;
- if (!next_index) break; /* If the next index is invalid, bail out now. */
+ code = ubik_VL_ListEntry(uclient, /*Ubik client structure */
+ 0, /*Ubik flags */
+ index, /*Current index */
+ &count, /*Ptr to working variable */
+ &next_index, /*Ptr to next index value to list */
+ &entry); /*Ptr to entry to fill */
+ if (code)
+ return code;
+ if (!next_index)
+ break; /* If the next index is invalid, bail out now. */
/* For each entry in the volume set */
- found = 0; /* No match in volume set yet */
- for (tve=avs->ventries; tve; tve=tve->next)
- { /*ve*/
+ found = 0; /* No match in volume set yet */
+ for (tve = avs->ventries; tve; tve = tve->next) { /*ve */
/* for each server in the vldb entry */
- for (srvpartpair=0; srvpartpair < entry.nServers; srvpartpair++)
- { /*s*/
- /* On the same server */
- if ( tve->server.sin_addr.s_addr &&
- !VLDB_IsSameAddrs(tve->server.sin_addr.s_addr,
- entry.serverNumber[srvpartpair],
- &code) ) {
- if (code) return(code);
+ for (srvpartpair = 0; srvpartpair < entry.nServers; srvpartpair++) { /*s */
+ /* On the same server */
+ if (tve->server.sin_addr.s_addr
+ && !VLDB_IsSameAddrs(tve->server.sin_addr.s_addr,
+ entry.serverNumber[srvpartpair],
+ &code)) {
+ if (code)
+ return (code);
continue;
}
-
+
/* On the same partition */
- if ( (tve->partition != -1) &&
- (tve->partition != entry.serverPartition[srvpartpair]) )
+ if ((tve->partition != -1)
+ && (tve->partition != entry.serverPartition[srvpartpair]))
continue;
/* If the volume entry is not compiled, then compile it */
- if (ctve != tve)
- {
+ if (ctve != tve) {
sprintf(patt, "^%s$", tve->name);
- errm = (char*)re_comp(patt);
- if (errm)
- {
- com_err(whoami, 0, "Can't compile regular expression '%s': %s",
+#ifdef HAVE_POSIX_REGEX
+ if (regcomp(&re, patt, REG_NOSUB) != 0) {
+ afs_com_err(whoami, 0, "Can't compile regular expression '%s'", patt);
+ return (-1);
+ }
+ need_regfree = 1;
+#else
+ errm = (char *)re_comp(patt);
+ if (errm) {
+ afs_com_err(whoami, 0,
+ "Can't compile regular expression '%s': %s",
patt, errm);
- return(-1);
+ return (-1);
}
+#endif
ctve = tve;
}
/* If the RW name matches the volume set entry, take
* it and exit. First choice is to use the RW volume.
*/
- if (entry.serverFlags[srvpartpair] & ITSRWVOL)
- {
- if (entry.flags & RW_EXISTS)
- {
- sprintf(patt, "%s", entry.name);
+ if (entry.serverFlags[srvpartpair] & ITSRWVOL) {
+ if (entry.flags & RW_EXISTS) {
+ sprintf(patt, "%s", entry.name);
+#ifdef HAVE_POSIX_REGEX
+ code = regexec(&re, patt, 0, NULL, 0);
+ if (code == 0) {
+#else
code = re_exec(patt);
- if (code == 1)
- {
+ if (code == 1) {
+#endif
found = 1;
foundentry = srvpartpair;
volType = RWVOL;
}
}
- /* If the BK name matches the volume set entry, take
+ /* If the BK name matches the volume set entry, take
* it and exit. Second choice is to use the BK volume.
*/
- if (entry.flags & BACK_EXISTS)
- {
- sprintf(patt, "%s.backup", entry.name);
+ if (entry.flags & BACK_EXISTS) {
+ sprintf(patt, "%s.backup", entry.name);
+#ifdef HAVE_POSIX_REGEX
+ code = regexec(&re, patt, 0, NULL, 0);
+ if (code == 0) {
+#else
code = re_exec(patt);
- if (code == 1)
- {
+ if (code == 1) {
+#endif
found = 1;
foundentry = srvpartpair;
volType = BACKVOL;
* it, but continue searching. Further entries may be
* RW or backup entries that will match.
*/
- else if ( !found &&
- (entry.serverFlags[srvpartpair] & ITSROVOL) &&
- (entry.flags & RO_EXISTS) )
- {
+ else if (!found && (entry.serverFlags[srvpartpair] & ITSROVOL)
+ && (entry.flags & RO_EXISTS)) {
sprintf(patt, "%s.readonly", entry.name);
+#ifdef HAVE_POSIX_REGEX
+ code = regexec(&re, patt, 0, NULL, 0);
+ if (code == 0) {
+#else
code = re_exec(patt);
- if (code == 1)
- {
- found = 1;
+ if (code == 1) {
+#endif
+ found = 1;
foundentry = srvpartpair;
volType = ROVOL;
}
}
-
+
if (code < 0)
- com_err(whoami, 0, "Internal error in regex package");
- } /*s*/
+ afs_com_err(whoami, 0, "Internal error in regex package");
+ } /*s */
/* If found a match, then create a new volume dump entry */
- if (found)
- { /*f*/
- /* Find server and partition structure to hang the entry off of */
- code = getSPEntries(entry.serverNumber[foundentry],
- entry.serverPartition[foundentry],
- &servers, &ss, &ps);
- if (code) {
- com_err(whoami, code, "");
- return(code);
- }
+ if (found) { /*f */
+ /* Find server and partition structure to hang the entry off of */
+ code =
+ getSPEntries(entry.serverNumber[foundentry],
+ entry.serverPartition[foundentry], &servers,
+ &ss, &ps);
+ if (code) {
+ afs_com_err(whoami, code, NULL);
+ return (code);
+ }
total++;
- tvd = (struct bc_volumeDump *) malloc(sizeof(struct bc_volumeDump));
- if (!tvd)
- {
- com_err(whoami, BC_NOMEM,"");
- return(BC_NOMEM);
+ tvd = (struct bc_volumeDump *)
+ malloc(sizeof(struct bc_volumeDump));
+ if (!tvd) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ return (BC_NOMEM);
}
memset(tvd, 0, sizeof(*tvd));
- tvd->name = (char *) malloc(strlen(entry.name)+10);
- if (!(tvd->name))
- {
- com_err(whoami, BC_NOMEM, "");
+ tvd->name = (char *)malloc(strlen(entry.name) + 10);
+ if (!(tvd->name)) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
free(tvd);
- return(BC_NOMEM);
+ return (BC_NOMEM);
}
strcpy(tvd->name, entry.name);
- if (volType == BACKVOL) strcat(tvd->name, ".backup");
- else if (volType == ROVOL) strcat(tvd->name, ".readonly");
- tvd->vid = entry.volumeId[volType];
- tvd->entry = tve;
- tvd->volType = volType;
- tvd->partition = entry.serverPartition[foundentry];
+ if (volType == BACKVOL)
+ strcat(tvd->name, ".backup");
+ else if (volType == ROVOL)
+ strcat(tvd->name, ".readonly");
+ tvd->vid = entry.volumeId[volType];
+ tvd->entry = tve;
+ tvd->volType = volType;
+ tvd->partition = entry.serverPartition[foundentry];
tvd->server.sin_addr.s_addr = entry.serverNumber[foundentry];
- tvd->server.sin_port = 0; /* default FS port */
- tvd->server.sin_family = AF_INET;
-
- /* String tvd off of partition struct */
- tvd->next = ps->vdlist;
- ps->vdlist = tvd;
- if (!tvd->next)
- ps->lastvdlist = tvd;
+ tvd->server.sin_port = 0; /* default FS port */
+ tvd->server.sin_family = AF_INET;
+
+ /* String tvd off of partition struct */
+ tvd->next = ps->vdlist;
+ ps->vdlist = tvd;
+ if (!tvd->next)
+ ps->lastvdlist = tvd;
break;
- } /*f*/
- } /*ve*/
- } /*w*/
+ } /*f */
+ } /*ve */
+ } /*w */
+#ifdef HAVE_POSIX_REGEX
+ if (need_regfree)
+ regfree(&re);
+#endif
/* Randomly link the volumedump entries together */
randSPEntries(servers, avols);
- fprintf (stderr, "Total number of volumes : %u\n", total);
- return(0);
-} /*EvalVolumeSet1*/
+ fprintf(stderr, "Total number of volumes : %u\n", total);
+ return (0);
+} /*EvalVolumeSet1 */
+
+char *
+compactTimeString(time_t *date, char *string, afs_int32 size)
+{
+ struct tm *ltime;
+
+ if (!string)
+ return NULL;
+
+ if (*date == NEVERDATE) {
+ sprintf(string, "NEVER");
+ } else {
+ ltime = localtime(date);
+ strftime(string, size, "%m/%d/%Y %H:%M", ltime);
+ }
+ return (string);
+}
/* compactDateString
* print out a date in compact format, 16 chars, format is
* exit:
* ptr to a string containing a representation of the date
*/
-char *compactDateString(date_long, string, size)
- afs_int32 *date_long, size;
- char *string;
+char *
+compactDateString(afs_uint32 *date_long, char *string, afs_int32 size)
{
- struct tm *ltime;
-
- if (!string) return 0;
-
- if (*date_long == NEVERDATE) {
- sprintf(string, "NEVER");
- } else {
- ltime = localtime(date_long);
- /* prints date in U.S. format of mm/dd/yyyy */
- strftime (string, size, "%m/%d/%Y %H:%M", ltime);
- }
- return(string);
+ time_t t = *date_long;
+ return compactTimeString(&t, string, size);
}
-afs_int32 bc_SafeATOI(anum)
- char *anum;
+
+afs_int32
+bc_SafeATOI(char *anum)
{
- afs_int32 total=0;
+ afs_int32 total = 0;
for (; *anum; anum++) {
- if ((*anum < '0') || (*anum > '9')) return -1;
- total = (10 * total) + (afs_int32)(*anum - '0');
+ if ((*anum < '0') || (*anum > '9'))
+ return -1;
+ total = (10 * total) + (afs_int32) (*anum - '0');
}
return total;
}
* by a character representing the units (K,M,G,T). Default is 'K'.
* Return the size in KBytes.
*/
-afs_int32 bc_FloatATOI(anum)
- char *anum;
+afs_int32
+bc_FloatATOI(char *anum)
{
float total = 0;
afs_int32 rtotal;
- afs_int32 fraction = 0; /* > 0 if past the decimal */
+ afs_int32 fraction = 0; /* > 0 if past the decimal */
for (; *anum; anum++) {
if ((*anum == 't') || (*anum == 'T')) {
- total *= 1024*1024*1024;
+ total *= 1024 * 1024 * 1024;
break;
}
if ((*anum == 'g') || (*anum == 'G')) {
- total *= 1024*1024;
+ total *= 1024 * 1024;
break;
}
if ((*anum == 'm') || (*anum == 'M')) {
break;
}
if (*anum == '.') {
- fraction = 10;
- continue;
+ fraction = 10;
+ continue;
}
- if ((*anum < '0') || (*anum > '9')) return -1;
+ if ((*anum < '0') || (*anum > '9'))
+ return -1;
if (!fraction) {
- total = (10. * total) + (float)(*anum - '0');
+ total = (10. * total) + (float)(*anum - '0');
} else {
- total += ((float)(*anum - '0')) / (float)fraction;
- fraction *= 10;
+ total += ((float)(*anum - '0')) / (float)fraction;
+ fraction *= 10;
}
}
- total += 0.5; /* Round up */
- if (total > 0x7fffffff) /* Don't go over 2G */
- total = 0x7fffffff;
+ total += 0.5; /* Round up */
+ if (total > 0x7fffffff) /* Don't go over 2G */
+ total = 0x7fffffff;
rtotal = (afs_int32) total;
return (rtotal);
}
/* make a copy of a string so that it can be freed later */
-char *bc_CopyString(astring)
- char *astring;
+char *
+bc_CopyString(char *astring)
{
afs_int32 tlen;
char *tp;
- if (!astring) return(NULL); /* propagate null strings easily */
+ if (!astring)
+ return (NULL); /* propagate null strings easily */
tlen = strlen(astring);
- tp = (char *) malloc(tlen+1); /* don't forget the terminating null */
- if (!tp)
- {
- com_err(whoami,BC_NOMEM,"");
- return(tp);
+ tp = (char *)malloc(tlen + 1); /* don't forget the terminating null */
+ if (!tp) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ return (tp);
}
strcpy(tp, astring);
return tp;
}
/* concatParams
- *
+ *
* Concatenates the parameters of an option and returns the string.
*
*/
-char *concatParams(itemPtr)
- struct cmd_item *itemPtr;
+char *
+concatParams(struct cmd_item *itemPtr)
{
- struct cmd_item *tempPtr;
- afs_int32 length = 0;
- char *string;
-
- /* compute the length of string required */
- for (tempPtr = itemPtr; tempPtr; tempPtr = tempPtr->next)
- {
- length += strlen(tempPtr->data);
- length++; /* space or null terminator */
- }
-
- if ( length == 0 ) /* no string (0 length) */
- {
- com_err(whoami, 0, "Can't have zero length date and time string");
- return(NULL);
- }
-
- string = (char *) malloc(length); /* allocate the string */
- if (!string)
- {
- com_err(whoami,BC_NOMEM,"");
- return(NULL);
- }
- string[0] = 0;
-
- tempPtr = itemPtr; /* now assemble the string */
- while ( tempPtr )
- {
- strcat(string, tempPtr->data);
- tempPtr = tempPtr->next;
- if ( tempPtr ) strcat(string, " ");
- }
-
- return(string); /* return the string */
+ struct cmd_item *tempPtr;
+ afs_int32 length = 0;
+ char *string;
+
+ /* compute the length of string required */
+ for (tempPtr = itemPtr; tempPtr; tempPtr = tempPtr->next) {
+ length += strlen(tempPtr->data);
+ length++; /* space or null terminator */
+ }
+
+ if (length == 0) { /* no string (0 length) */
+ afs_com_err(whoami, 0, "Can't have zero length date and time string");
+ return (NULL);
+ }
+
+ string = (char *)malloc(length); /* allocate the string */
+ if (!string) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ return (NULL);
+ }
+ string[0] = 0;
+
+ tempPtr = itemPtr; /* now assemble the string */
+ while (tempPtr) {
+ strcat(string, tempPtr->data);
+ tempPtr = tempPtr->next;
+ if (tempPtr)
+ strcat(string, " ");
+ }
+
+ return (string); /* return the string */
}
/* printIfStatus
* print out an interface status node as received from butc
*/
-printIfStatus(statusPtr)
- struct tciStatusS *statusPtr;
+void
+printIfStatus(struct tciStatusS *statusPtr)
{
printf("Task %d: %s: ", statusPtr->taskId, statusPtr->taskName);
- if ( statusPtr->nKBytes )
- printf("%ld Kbytes transferred", statusPtr->nKBytes);
- if ( strlen(statusPtr->volumeName) != 0 )
- {
- if ( statusPtr->nKBytes ) printf(", ");
+ if (statusPtr->nKBytes)
+ printf("%ld Kbytes transferred", (long unsigned int) statusPtr->nKBytes);
+ if (strlen(statusPtr->volumeName) != 0) {
+ if (statusPtr->nKBytes)
+ printf(", ");
printf("volume %s", statusPtr->volumeName);
}
/* orphan */
- if ( statusPtr->flags & ABORT_REQUEST )
+ if (statusPtr->flags & ABORT_REQUEST)
printf(" [abort request rcvd]");
-
- if ( statusPtr->flags & ABORT_DONE )
+
+ if (statusPtr->flags & ABORT_DONE)
printf(" [abort complete]");
-
- if ( statusPtr->flags & OPR_WAIT )
+
+ if (statusPtr->flags & OPR_WAIT)
printf(" [operator wait]");
-
- if ( statusPtr->flags & CALL_WAIT )
+
+ if (statusPtr->flags & CALL_WAIT)
printf(" [callout in progress]");
-
- if ( statusPtr->flags & DRIVE_WAIT )
+
+ if (statusPtr->flags & DRIVE_WAIT)
printf(" [drive wait]");
- if ( statusPtr->flags & TASK_DONE )
+ if (statusPtr->flags & TASK_DONE)
printf(" [done]");
printf("\n");
}
-afs_int32 getPortOffset(port)
- char *port;
+afs_int32
+getPortOffset(char *port)
{
- afs_int32 portOffset;
-
- portOffset = bc_SafeATOI(port);
-
- if (portOffset < 0) {
- com_err(whoami,0,"Can't decode port offset '%s'", port);
- return(-1);
- }
- else if (portOffset > BC_MAXPORTOFFSET) {
- com_err(whoami,0,"%u exceeds max port offset %u",portOffset,BC_MAXPORTOFFSET);
- return(-1);
- }
- return(portOffset);
+ afs_int32 portOffset;
+
+ portOffset = bc_SafeATOI(port);
+
+ if (portOffset < 0) {
+ afs_com_err(whoami, 0, "Can't decode port offset '%s'", port);
+ return (-1);
+ } else if (portOffset > BC_MAXPORTOFFSET) {
+ afs_com_err(whoami, 0, "%u exceeds max port offset %u", portOffset,
+ BC_MAXPORTOFFSET);
+ return (-1);
+ }
+ return (portOffset);
}
/* bc_GetTapeStatusCmd
* display status of all tasks on a particular tape coordinator
*/
-
-bc_GetTapeStatusCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_GetTapeStatusCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
- afs_int32 index, dumpID;
struct rx_connection *tconn;
afs_int32 portOffset = 0;
code = bc_UpdateHosts();
if (code) {
- com_err(whoami, code, "; Can't retrieve tape hosts");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve tape hosts");
+ return (code);
}
if (as->parms[0].items) {
- portOffset = getPortOffset(as->parms[0].items->data);
- if (portOffset < 0) return(BC_BADARG);
+ portOffset = getPortOffset(as->parms[0].items->data);
+ if (portOffset < 0)
+ return (BC_BADARG);
}
code = ConnectButc(bc_globalConfig, portOffset, &tconn);
- if (code) return(code);
-
+ if (code)
+ return (code);
+
flags = TSK_STAT_FIRST;
taskId = 0;
ntasks = 0;
- while ( (flags & TSK_STAT_END) == 0 )
- {
+ while ((flags & TSK_STAT_END) == 0) {
code = TC_ScanStatus(tconn, &taskId, &status, &flags);
- if (code)
- {
- if (code == TC_NOTASKS) break;
- com_err(whoami, code, "; Can't get status from butc");
- return(-1);
+ if (code) {
+ if (code == TC_NOTASKS)
+ break;
+ afs_com_err(whoami, code, "; Can't get status from butc");
+ return (-1);
}
- if ( (flags & TSK_STAT_NOTFOUND) ) break; /* Can't find the task id */
- flags &= ~TSK_STAT_FIRST; /* turn off flag */
+ if ((flags & TSK_STAT_NOTFOUND))
+ break; /* Can't find the task id */
+ flags &= ~TSK_STAT_FIRST; /* turn off flag */
printIfStatus(&status);
ntasks++;
printf("Tape coordinator is idle\n");
if (flags & TSK_STAT_ADSM)
- printf("TSM Tape coordinator\n");
+ printf("TSM Tape coordinator\n");
else if (flags & TSK_STAT_XBSA)
- printf("XBSA Tape coordinator\n");
+ printf("XBSA Tape coordinator\n");
- return(0);
+ return (0);
}
extern struct Lock dispatchLock;
/* bc_WaitForNoJobs
* wait for all jobs to terminate
*/
-bc_WaitForNoJobs()
+int
+bc_WaitForNoJobs(void)
{
- afs_int32 wcode = 0;
int i;
- int waitmsg = 1;
int usefulJobRunning = 1;
-
+
extern dlqlinkT statusHead;
- statusP ptr;
- dlqlinkP dptr;
- com_err(whoami, 0, "waiting for job termination");
+ afs_com_err(whoami, 0, "waiting for job termination");
- while (usefulJobRunning)
- {
+ while (usefulJobRunning) {
usefulJobRunning = (dlqEmpty(&statusHead) ? 0 : 1);
- if (dispatchLock.excl_locked) usefulJobRunning = 1;
- for (i=0; (!usefulJobRunning && (i<BC_MAXSIMDUMPS)); i++)
- {
+ if (dispatchLock.excl_locked)
+ usefulJobRunning = 1;
+ for (i = 0; (!usefulJobRunning && (i < BC_MAXSIMDUMPS)); i++) {
if (bc_dumpTasks[i].flags & BC_DI_INUSE)
- usefulJobRunning = 1;
+ usefulJobRunning = 1;
}
/* Wait 5 seconds and check again */
- if (usefulJobRunning) IOMGR_Sleep(5);
+ if (usefulJobRunning)
+ IOMGR_Sleep(5);
}
- return(lastTaskCode);
+ return (lastTaskCode);
}
/* bc_JobsCmd
* parameters
* ignored - a null "as" prints only jobs.
*/
-
-bc_JobsCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_JobsCmd(struct cmd_syndesc *as, void *arock)
{
- int i;
- afs_int32 prevTime;
- struct bc_dumpTask *td;
+ afs_int32 prevTime;
dlqlinkP ptr;
statusP statusPtr;
char ds[50];
- statusP youngest;
- dlqlinkT atJobsHead;
+ statusP youngest;
+ dlqlinkT atJobsHead;
extern dlqlinkT statusHead;
dlqInit(&atJobsHead);
lock_Status();
ptr = (&statusHead)->dlq_next;
- while ( ptr != &statusHead )
- {
+ while (ptr != &statusHead) {
statusPtr = (statusP) ptr;
ptr = ptr->dlq_next;
-
- if ( statusPtr->scheduledDump )
- {
- dlqUnlink((dlqlinkP)statusPtr);
- dlqLinkb(&atJobsHead, (dlqlinkP)statusPtr);
- }
- else
- {
+
+ if (statusPtr->scheduledDump) {
+ dlqUnlink((dlqlinkP) statusPtr);
+ dlqLinkb(&atJobsHead, (dlqlinkP) statusPtr);
+ } else {
printf("Job %d:", statusPtr->jobNumber);
printf(" %s", statusPtr->taskName);
-
- if ( statusPtr->dbDumpId )
- printf(": DumpID %u", statusPtr->dbDumpId);
- if ( statusPtr->nKBytes )
- printf(", %ld Kbytes", statusPtr->nKBytes);
- if ( strlen(statusPtr->volumeName) != 0 )
- printf(", volume %s", statusPtr->volumeName);
-
- if ( statusPtr->flags & CONTACT_LOST )
- printf(" [butc contact lost]");
-
- if ( statusPtr->flags & ABORT_REQUEST )
- printf(" [abort request]");
-
- if ( statusPtr->flags & ABORT_SENT )
- printf(" [abort sent]");
-
- if ( statusPtr->flags & OPR_WAIT )
- printf(" [operator wait]");
-
- if ( statusPtr->flags & CALL_WAIT )
- printf(" [callout in progress]");
-
- if ( statusPtr->flags & DRIVE_WAIT )
- printf(" [drive wait]");
+
+ if (statusPtr->dbDumpId)
+ printf(": DumpID %u", statusPtr->dbDumpId);
+ if (statusPtr->nKBytes)
+ printf(", %ld Kbytes", afs_printable_int32_ld(statusPtr->nKBytes));
+ if (strlen(statusPtr->volumeName) != 0)
+ printf(", volume %s", statusPtr->volumeName);
+
+ if (statusPtr->flags & CONTACT_LOST)
+ printf(" [butc contact lost]");
+
+ if (statusPtr->flags & ABORT_REQUEST)
+ printf(" [abort request]");
+
+ if (statusPtr->flags & ABORT_SENT)
+ printf(" [abort sent]");
+
+ if (statusPtr->flags & OPR_WAIT)
+ printf(" [operator wait]");
+
+ if (statusPtr->flags & CALL_WAIT)
+ printf(" [callout in progress]");
+
+ if (statusPtr->flags & DRIVE_WAIT)
+ printf(" [drive wait]");
printf("\n");
}
}
- /*
+ /*
* Now print the scheduled dumps.
*/
- if ( !dlqEmpty(&statusHead) && as )
- printf("\n"); /* blank line between running and scheduled dumps */
+ if (!dlqEmpty(&statusHead) && as)
+ printf("\n"); /* blank line between running and scheduled dumps */
prevTime = 0;
- while ( !dlqEmpty(&atJobsHead) )
- {
- ptr = (&atJobsHead) -> dlq_next;
+ while (!dlqEmpty(&atJobsHead)) {
+ ptr = (&atJobsHead)->dlq_next;
youngest = (statusP) ptr;
- ptr = ptr->dlq_next;
- while ( ptr != &atJobsHead ) /* Find the dump that starts the earliest */
- {
+ ptr = ptr->dlq_next;
+ while (ptr != &atJobsHead) { /* Find the dump that starts the earliest */
statusPtr = (statusP) ptr;
- if ( statusPtr->scheduledDump < youngest->scheduledDump )
- youngest = statusPtr;
+ if (statusPtr->scheduledDump < youngest->scheduledDump)
+ youngest = statusPtr;
ptr = ptr->dlq_next;
}
-
+
/* Print token expiration time */
- if ( (ttoken.endTime > prevTime) && (ttoken.endTime <= youngest->scheduledDump) &&
- as && (ttoken.endTime != NEVERDATE))
- {
- if (ttoken.endTime > time(0)) {
- compactDateString(&ttoken.endTime, ds, 50);
- printf(" %16s: TOKEN EXPIRATION\n", ds);
- } else {
- printf(" TOKEN HAS EXPIRED\n");
- }
+ if ((tokenExpires > prevTime)
+ && (tokenExpires <= youngest->scheduledDump) && as
+ && (tokenExpires != NEVERDATE)) {
+ if (tokenExpires > time(0)) {
+ compactTimeString(&tokenExpires, ds, 50);
+ printf(" %16s: TOKEN EXPIRATION\n", ds);
+ } else {
+ printf(" TOKEN HAS EXPIRED\n");
+ }
}
prevTime = youngest->scheduledDump;
compactDateString(&youngest->scheduledDump, ds, 50);
printf("Job %d:", youngest->jobNumber);
printf(" %16s: %s", ds, youngest->cmdLine);
- printf("\n");
-
+ printf("\n");
+
/* return to original list */
- dlqUnlink((dlqlinkP)youngest);
- dlqLinkb(&statusHead, (dlqlinkP)youngest);
+ dlqUnlink((dlqlinkP) youngest);
+ dlqLinkb(&statusHead, (dlqlinkP) youngest);
}
/* Print token expiration time if havn't already */
- if ( (ttoken.endTime == NEVERDATE) && as )
- printf(" : TOKEN NEVER EXPIRES\n");
- else if ( (ttoken.endTime > prevTime) && as )
- {
- if (ttoken.endTime > time(0)) {
- compactDateString(&ttoken.endTime, ds, 50);
+ if ((tokenExpires == NEVERDATE) && as)
+ printf(" : TOKEN NEVER EXPIRES\n");
+ else if ((tokenExpires > prevTime) && as) {
+ if (tokenExpires > time(0)) {
+ compactTimeString(&tokenExpires, ds, 50);
printf(" %16s: TOKEN EXPIRATION\n", ds);
} else {
printf(" : TOKEN HAS EXPIRED\n");
return 0;
}
-bc_KillCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_KillCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 i;
afs_int32 slot;
struct bc_dumpTask *td;
char *tp;
char tbuffer[256];
- afs_int32 code;
dlqlinkP ptr;
statusP statusPtr;
extern dlqlinkT statusHead;
- extern statusP findStatus();
-
tp = as->parms[0].items->data;
- if (strchr(tp, '.') == 0)
- {
+ if (strchr(tp, '.') == 0) {
slot = bc_SafeATOI(tp);
- if (slot == -1)
- {
- com_err(whoami,0,"Bad syntax for number '%s'", tp);
+ if (slot == -1) {
+ afs_com_err(whoami, 0, "Bad syntax for number '%s'", tp);
return -1;
}
lock_Status();
ptr = (&statusHead)->dlq_next;
- while ( ptr != &statusHead )
- {
+ while (ptr != &statusHead) {
statusPtr = (statusP) ptr;
- if ( statusPtr->jobNumber == slot )
- {
+ if (statusPtr->jobNumber == slot) {
statusPtr->flags |= ABORT_REQUEST;
unlock_Status();
- return(0);
+ return (0);
}
ptr = ptr->dlq_next;
}
unlock_Status();
fprintf(stderr, "Job %d not found\n", slot);
- return(-1);
- }
- else
- {
+ return (-1);
+ } else {
/* vol.dump */
td = bc_dumpTasks;
- for(i=0;i<BC_MAXSIMDUMPS;i++, td++)
- {
- if (td->flags & BC_DI_INUSE)
- {
+ for (i = 0; i < BC_MAXSIMDUMPS; i++, td++) {
+ if (td->flags & BC_DI_INUSE) {
/* compute name */
strcpy(tbuffer, td->volSetName);
strcat(tbuffer, ".");
break;
}
}
- if (i >= BC_MAXSIMDUMPS)
- {
- com_err(whoami,0,"Can't find job %s", tp);
+ if (i >= BC_MAXSIMDUMPS) {
+ afs_com_err(whoami, 0, "Can't find job %s", tp);
return -1;
}
lock_Status();
statusPtr = findStatus(td->dumpID);
- if ( statusPtr == 0 )
- {
- com_err(whoami, 0, "Can't locate status - internal error");
+ if (statusPtr == 0) {
+ afs_com_err(whoami, 0, "Can't locate status - internal error");
unlock_Status();
- return(-1);
+ return (-1);
}
statusPtr->flags |= ABORT_REQUEST;
unlock_Status();
- return(0);
}
return 0;
}
/* restore a volume or volumes */
-bc_VolRestoreCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_VolRestoreCmd(struct cmd_syndesc *as, void *arock)
{
/*
* parm 0 is the new server to restore to
* a new volume ID for the restored volume. If a new extension is specified,
* we add that extension to the volume name of the restored volume.
*/
- struct bc_volumeEntry tvolumeEntry; /* entry within the volume set */
+ struct bc_volumeEntry tvolumeEntry; /* entry within the volume set */
struct bc_volumeDump *volsToRestore = (struct bc_volumeDump *)0;
- struct bc_volumeDump *lastVol = (struct bc_volumeDump *)0;
- struct bc_volumeDump *tvol; /* temp for same */
- struct sockaddr_in destServ; /* machine to which to restore volumes */
- afs_int32 destPartition; /* partition to which to restore volumes */
+ struct bc_volumeDump *lastVol = (struct bc_volumeDump *)0;
+ struct bc_volumeDump *tvol; /* temp for same */
+ struct sockaddr_in destServ; /* machine to which to restore volumes */
+ afs_int32 destPartition; /* partition to which to restore volumes */
char *tp;
struct cmd_item *ti;
afs_int32 code;
int oldFlag;
afs_int32 fromDate;
+ afs_int32 dumpID = 0;
char *newExt, *timeString;
- afs_int32 i, portRemain;
+ afs_int32 i;
afs_int32 *ports = NULL;
- afs_int32 portCount=0;
- int dontExecute;
+ afs_int32 portCount = 0;
+ int dontExecute;
code = bc_UpdateHosts();
if (code) {
- com_err(whoami, code, "; Can't retrieve tape hosts");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve tape hosts");
+ return (code);
}
/* specified other destination host */
- if (as->parms[0].items)
- {
+ if (as->parms[0].items) {
tp = as->parms[0].items->data;
- if (bc_ParseHost(tp, &destServ))
- {
- com_err(whoami,0,"Failed to locate destination host '%s'", tp);
+ if (bc_ParseHost(tp, &destServ)) {
+ afs_com_err(whoami, 0, "Failed to locate destination host '%s'", tp);
return -1;
}
}
/* specified other destination partition */
- if (as->parms[1].items)
- {
+ if (as->parms[1].items) {
tp = as->parms[1].items->data;
- if (bc_GetPartitionID(tp, &destPartition))
- {
- com_err(whoami,0,"Can't parse destination partition '%s'", tp);
+ if (bc_GetPartitionID(tp, &destPartition)) {
+ afs_com_err(whoami, 0, "Can't parse destination partition '%s'", tp);
return -1;
}
}
- for (ti=as->parms[2].items; ti; ti=ti->next)
- {
+ for (ti = as->parms[2].items; ti; ti = ti->next) {
/* build list of volume items */
- tvol = (struct bc_volumeDump *) malloc(sizeof(struct bc_volumeDump));
- if (!tvol)
- {
- com_err(whoami,BC_NOMEM,"");
+ tvol = (struct bc_volumeDump *)malloc(sizeof(struct bc_volumeDump));
+ if (!tvol) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
return BC_NOMEM;
}
memset(tvol, 0, sizeof(struct bc_volumeDump));
- tvol->name = (char *) malloc(VOLSER_MAXVOLNAME +1);
- if (!tvol->name)
- {
- com_err(whoami,BC_NOMEM,"");
+ tvol->name = (char *)malloc(VOLSER_MAXVOLNAME + 1);
+ if (!tvol->name) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
return BC_NOMEM;
}
- strncpy(tvol->name, ti->data,VOLSER_OLDMAXVOLNAME);
+ strncpy(tvol->name, ti->data, VOLSER_OLDMAXVOLNAME);
tvol->entry = &tvolumeEntry;
- if (lastVol) lastVol->next = tvol; /* thread onto end of list */
- else volsToRestore = tvol;
+ if (lastVol)
+ lastVol->next = tvol; /* thread onto end of list */
+ else
+ volsToRestore = tvol;
lastVol = tvol;
}
- if (as->parms[4].items)
- {
- timeString = concatParams(as->parms[4].items);
- if (!timeString) return(-1);
-
+ if (as->parms[4].items) {
+ timeString = concatParams(as->parms[4].items);
+ if (!timeString)
+ return (-1);
+
code = ktime_DateToLong(timeString, &fromDate);
- free (timeString);
- if (code)
- {
- com_err(whoami,0,"Can't parse restore date and time");
- com_err(whoami,0,"%s", ktime_GetDateUsage());
+ free(timeString);
+ if (code) {
+ afs_com_err(whoami, 0, "Can't parse restore date and time");
+ afs_com_err(whoami, 0, "%s", ktime_GetDateUsage());
return code;
}
- }
- else
- {
- fromDate = 0x7fffffff; /* latest one */
+ } else {
+ fromDate = 0x7fffffff; /* latest one */
}
- newExt = (as->parms[3].items ? as->parms[3].items->data : NULL);
+ newExt = (as->parms[3].items ? as->parms[3].items->data : NULL);
oldFlag = 0;
/* Read all the port offsets into the ports array. The first element in the
- * array is for full restore and the rest are for incremental restores
+ * array is for full restore and the rest are for incremental restores
*/
if (as->parms[5].items) {
- for (ti=as->parms[5].items; ti; ti=ti->next) portCount++;
- ports = (afs_int32 *)malloc(portCount*sizeof(afs_int32));
+ for (ti = as->parms[5].items; ti; ti = ti->next)
+ portCount++;
+ ports = (afs_int32 *) malloc(portCount * sizeof(afs_int32));
if (!ports) {
- com_err(whoami,BC_NOMEM,"");
+ afs_com_err(whoami, BC_NOMEM, NULL);
return BC_NOMEM;
}
- for (ti=as->parms[5].items, i=0; ti; ti=ti->next, i++) {
- ports[i] = getPortOffset(ti->data);
- if (ports[i] < 0) return(BC_BADARG);
+ for (ti = as->parms[5].items, i = 0; ti; ti = ti->next, i++) {
+ ports[i] = getPortOffset(ti->data);
+ if (ports[i] < 0)
+ return (BC_BADARG);
}
}
- dontExecute = (as->parms[6].items ? 1 : 0); /* -n */
+ dontExecute = (as->parms[6].items ? 1 : 0); /* -n */
+
+ if (as->parms[7].items)
+ {
+ dumpID = atoi(as->parms[7].items->data);
+ if (dumpID <= 0)
+ dumpID = 0;
+ }
/*
* Perform the call to start the restore.
*/
- code = bc_StartDmpRst(bc_globalConfig, "volume", "restore", volsToRestore, &destServ,
- destPartition, fromDate, newExt, oldFlag,
- /*parentDump*/0, /*dumpLevel*/0,
- bc_Restorer, ports, portCount,
- /*dumpSched*/0, /*append*/0, dontExecute);
- if (code) com_err(whoami,code,"; Failed to queue restore");
-
- return(code);
+ code =
+ bc_StartDmpRst(bc_globalConfig, "volume", "restore", volsToRestore,
+ &destServ, destPartition, fromDate, newExt, oldFlag,
+ /*parentDump */ dumpID, /*dumpLevel */ 0,
+ bc_Restorer, ports, portCount,
+ /*dumpSched */ NULL, /*append */ 0, dontExecute);
+ if (code)
+ afs_com_err(whoami, code, "; Failed to queue restore");
+
+ return (code);
}
/* restore a whole partition or server */
* various optional
*/
-bc_DiskRestoreCmd(as, arock)
-struct cmd_syndesc *as;
-char *arock; {
- struct bc_volumeSet tvolumeSet; /* temporary volume set for EvalVolumeSet call */
- struct bc_volumeEntry tvolumeEntry; /* entry within the volume set */
+int
+bc_DiskRestoreCmd(struct cmd_syndesc *as, void *arock)
+{
+ struct bc_volumeSet tvolumeSet; /* temporary volume set for EvalVolumeSet call */
+ struct bc_volumeEntry tvolumeEntry; /* entry within the volume set */
struct bc_volumeDump *volsToRestore = (struct bc_volumeDump *)0;
- struct sockaddr_in destServ; /* machine to which to restore volumes */
- afs_int32 destPartition; /* partition to which to restore volumes */
+ struct sockaddr_in destServ; /* machine to which to restore volumes */
+ afs_int32 destPartition; /* partition to which to restore volumes */
char *tp;
afs_int32 code;
int oldFlag;
afs_int32 fromDate;
char *newExt;
afs_int32 *ports = NULL;
- afs_int32 portCount=0;
- int dontExecute;
+ afs_int32 portCount = 0;
+ int dontExecute;
struct bc_volumeDump *prev, *tvol, *nextvol;
struct cmd_item *ti;
afs_int32 i;
code = bc_UpdateVolumeSet();
if (code) {
- com_err(whoami, code, "; Can't retrieve volume sets");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve volume sets");
+ return (code);
}
code = bc_UpdateHosts();
if (code) {
- com_err(whoami, code, "; Can't retrieve tape hosts");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve tape hosts");
+ return (code);
}
/* create a volume set corresponding to the volume pattern we've been given */
tvolumeEntry.serverName = as->parms[0].items->data;
tvolumeEntry.partname = as->parms[1].items->data;
- if (bc_GetPartitionID(tvolumeEntry.partname, &tvolumeEntry.partition))
- {
- com_err(whoami,0,"Can't parse partition '%s'", tvolumeEntry.partname);
+ if (bc_GetPartitionID(tvolumeEntry.partname, &tvolumeEntry.partition)) {
+ afs_com_err(whoami, 0, "Can't parse partition '%s'",
+ tvolumeEntry.partname);
return -1;
}
- if (bc_ParseHost(tvolumeEntry.serverName, &tvolumeEntry.server))
- {
- com_err(whoami,0,"Can't locate host '%s'", tvolumeEntry.serverName);
+ if (bc_ParseHost(tvolumeEntry.serverName, &tvolumeEntry.server)) {
+ afs_com_err(whoami, 0, "Can't locate host '%s'", tvolumeEntry.serverName);
return -1;
}
/* specified other destination host */
- if (as->parms[8].items)
- {
+ if (as->parms[8].items) {
tp = as->parms[8].items->data;
- if (bc_ParseHost(tp, &destServ))
- {
- com_err(whoami,0,"Can't locate destination host '%s'", tp);
+ if (bc_ParseHost(tp, &destServ)) {
+ afs_com_err(whoami, 0, "Can't locate destination host '%s'", tp);
return -1;
}
- }
- else /* use destination host == original host */
+ } else /* use destination host == original host */
memcpy(&destServ, &tvolumeEntry.server, sizeof(destServ));
/* specified other destination partition */
- if (as->parms[9].items)
- {
+ if (as->parms[9].items) {
tp = as->parms[9].items->data;
- if (bc_GetPartitionID(tp, &destPartition))
- {
- com_err(whoami,0,"Can't parse destination partition '%s'", tp);
+ if (bc_GetPartitionID(tp, &destPartition)) {
+ afs_com_err(whoami, 0, "Can't parse destination partition '%s'", tp);
return -1;
}
- }
- else /* use original partition */
+ } else /* use original partition */
destPartition = tvolumeEntry.partition;
- tvolumeEntry.name = ".*"; /* match all volumes (this should be a parameter) */
+ tvolumeEntry.name = ".*"; /* match all volumes (this should be a parameter) */
if (as->parms[2].items) {
- for (ti=as->parms[2].items; ti; ti=ti->next) portCount++;
- ports = (afs_int32 *)malloc(portCount*sizeof(afs_int32));
- if (!ports) {
- com_err(whoami,BC_NOMEM,"");
- return BC_NOMEM;
- }
+ for (ti = as->parms[2].items; ti; ti = ti->next)
+ portCount++;
+ ports = (afs_int32 *) malloc(portCount * sizeof(afs_int32));
+ if (!ports) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ return BC_NOMEM;
+ }
- for (ti=as->parms[2].items, i=0; ti; ti=ti->next, i++) {
- ports[i] = getPortOffset(ti->data);
- if (ports[i] < 0) return(BC_BADARG);
- }
+ for (ti = as->parms[2].items, i = 0; ti; ti = ti->next, i++) {
+ ports[i] = getPortOffset(ti->data);
+ if (ports[i] < 0)
+ return (BC_BADARG);
+ }
}
- newExt = (as->parms[10].items ? as->parms[10].items->data : NULL);
- dontExecute = (as->parms[11].items ? 1 : 0); /* -n */
+ newExt = (as->parms[10].items ? as->parms[10].items->data : NULL);
+ dontExecute = (as->parms[11].items ? 1 : 0); /* -n */
/*
* Expand out the volume set into its component list of volumes, by calling VLDB server.
*/
- code = bc_EvalVolumeSet(bc_globalConfig, &tvolumeSet, &volsToRestore, cstruct);
- if (code)
- {
- com_err(whoami,code,"; Failed to evaluate volume set");
- return(-1);
+ code =
+ bc_EvalVolumeSet(bc_globalConfig, &tvolumeSet, &volsToRestore,
+ cstruct);
+ if (code) {
+ afs_com_err(whoami, code, "; Failed to evaluate volume set");
+ return (-1);
}
- /* Since we want only RW volumes, remove any
+ /* Since we want only RW volumes, remove any
* BK or RO volumes from the list.
*/
- for (prev=0, tvol=volsToRestore; tvol; tvol=nextvol) {
- nextvol = tvol->next;
- if (BackupName(tvol->name)) {
- if (tvol->name)
- fprintf (stderr, "Will not restore volume %s (its RW does not reside on the partition)\n", tvol->name);
-
- if (tvol == volsToRestore) {
- volsToRestore = nextvol;
- } else {
- prev->next = nextvol;
- }
- if (tvol->name) free(tvol->name);
- free(tvol);
- } else {
- prev = tvol;
- }
+ for (prev = 0, tvol = volsToRestore; tvol; tvol = nextvol) {
+ nextvol = tvol->next;
+ if (BackupName(tvol->name)) {
+ if (tvol->name)
+ fprintf(stderr,
+ "Will not restore volume %s (its RW does not reside on the partition)\n",
+ tvol->name);
+
+ if (tvol == volsToRestore) {
+ volsToRestore = nextvol;
+ } else {
+ prev->next = nextvol;
+ }
+ if (tvol->name)
+ free(tvol->name);
+ free(tvol);
+ } else {
+ prev = tvol;
+ }
}
fromDate = 0x7fffffff; /* last one before this date */
/*
* Perform the call to start the dump.
*/
- code = bc_StartDmpRst(bc_globalConfig, "disk", "restore", volsToRestore, &destServ,
- destPartition, fromDate, newExt, oldFlag,
- /*parentDump*/0, /*dumpLevel*/0,
- bc_Restorer, ports, portCount,
- /*dumpSched*/0, /*append*/0, dontExecute);
- if (code) com_err(whoami,code,"; Failed to queue restore");
-
- return(code);
+ code =
+ bc_StartDmpRst(bc_globalConfig, "disk", "restore", volsToRestore,
+ &destServ, destPartition, fromDate, newExt, oldFlag,
+ /*parentDump */ 0, /*dumpLevel */ 0,
+ bc_Restorer, ports, portCount,
+ /*dumpSched */ NULL, /*append */ 0, dontExecute);
+ if (code)
+ afs_com_err(whoami, code, "; Failed to queue restore");
+
+ return (code);
}
/* bc_VolsetRestoreCmd
* restore a volumeset or list of volumes.
*/
-bc_VolsetRestoreCmd (as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_VolsetRestoreCmd(struct cmd_syndesc *as, void *arock)
{
int oldFlag;
long fromDate;
char *newExt;
- int dontExecute;
- afs_int32 *ports = NULL;
- afs_int32 portCount=0;
- afs_int32 code = 0;
- afs_int32 portoffset = 0;
- char *volsetName;
- struct bc_volumeSet *volsetPtr; /* Ptr to list of generated volume info*/
+ int dontExecute;
+ afs_int32 *ports = NULL;
+ afs_int32 portCount = 0;
+ afs_int32 code = 0;
+ char *volsetName;
+ struct bc_volumeSet *volsetPtr; /* Ptr to list of generated volume info */
struct bc_volumeDump *volsToRestore = (struct bc_volumeDump *)0;
- struct bc_volumeDump *lastVol = (struct bc_volumeDump *)0;
- struct sockaddr_in destServer; /* machine to which to restore volume */
- afs_int32 destPartition; /* partition to which to restore volumes */
- struct cmd_item *ti;
- afs_int32 i;
-
+ struct bc_volumeDump *lastVol = (struct bc_volumeDump *)0;
+ struct sockaddr_in destServer; /* machine to which to restore volume */
+ afs_int32 destPartition; /* partition to which to restore volumes */
+ struct cmd_item *ti;
+ afs_int32 i;
+
code = bc_UpdateVolumeSet();
if (code) {
- com_err(whoami, code, "; Can't retrieve volume sets");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve volume sets");
+ return (code);
}
code = bc_UpdateHosts();
if (code) {
- com_err(whoami, code, "; Can't retrieve tape hosts");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve tape hosts");
+ return (code);
}
- if (as->parms[0].items)
- {
- if (as->parms[1].items)
- {
- com_err(whoami, 0, "Can't have both -name and -file options");
- return(-1);
+ if (as->parms[0].items) {
+ if (as->parms[1].items) {
+ afs_com_err(whoami, 0, "Can't have both -name and -file options");
+ return (-1);
}
volsetName = as->parms[0].items->data;
- volsetPtr = bc_FindVolumeSet(bc_globalConfig, volsetName);
- if (!volsetPtr)
- {
- com_err(whoami,0,"Can't find volume set '%s' in backup database", volsetName);
- return(-1);
+ volsetPtr = bc_FindVolumeSet(bc_globalConfig, volsetName);
+ if (!volsetPtr) {
+ afs_com_err(whoami, 0,
+ "Can't find volume set '%s' in backup database",
+ volsetName);
+ return (-1);
}
/* Expand out the volume set into its component list of volumes. */
- code = bc_EvalVolumeSet(bc_globalConfig, volsetPtr, &volsToRestore, cstruct);
- if (code)
- {
- com_err(whoami,code,"; Failed to evaluate volume set");
- return(-1);
+ code =
+ bc_EvalVolumeSet(bc_globalConfig, volsetPtr, &volsToRestore,
+ cstruct);
+ if (code) {
+ afs_com_err(whoami, code, "; Failed to evaluate volume set");
+ return (-1);
}
- }
- else if (as->parms[1].items)
- {
- FILE *fd;
+ } else if (as->parms[1].items) {
+ FILE *fd;
char line[256];
char server[50], partition[50], volume[50], rest[256];
long count;
struct bc_volumeDump *tvol;
- fd = fopen(as->parms[1].items->data, "r");
- if (!fd)
- {
- com_err(whoami,errno,"; Cannot open file '%s'", as->parms[1].items->data);
- return(-1);
- }
-
- while ( fgets(line, 255, fd) )
- {
- count = sscanf(line, "%s %s %s %s", server, partition, volume, rest);
-
- if (count <= 0) continue;
- if (count < 3)
- {
- fprintf(stderr,
+ fd = fopen(as->parms[1].items->data, "r");
+ if (!fd) {
+ afs_com_err(whoami, errno, "; Cannot open file '%s'",
+ as->parms[1].items->data);
+ return (-1);
+ }
+
+ while (fgets(line, 255, fd)) {
+ count =
+ sscanf(line, "%s %s %s %s", server, partition, volume, rest);
+
+ if (count <= 0)
+ continue;
+ if (count < 3) {
+ fprintf(stderr,
"Invalid volumeset file format: Wrong number of arguments: Ignoring\n");
fprintf(stderr, " %s", line);
continue;
}
- if ( bc_ParseHost(server,&destServer) )
- {
- com_err(whoami,0,"Failed to locate host '%s'", server);
+ if (bc_ParseHost(server, &destServer)) {
+ afs_com_err(whoami, 0, "Failed to locate host '%s'", server);
continue;
}
- if ( bc_GetPartitionID(partition,&destPartition) )
- {
- com_err(whoami,0,"Failed to parse destination partition '%s'", partition);
+ if (bc_GetPartitionID(partition, &destPartition)) {
+ afs_com_err(whoami, 0,
+ "Failed to parse destination partition '%s'",
+ partition);
continue;
}
/* Allocate a volumeDump structure and link it in */
- tvol = (struct bc_volumeDump *) malloc(sizeof(struct bc_volumeDump));
+ tvol =
+ (struct bc_volumeDump *)malloc(sizeof(struct bc_volumeDump));
memset(tvol, 0, sizeof(struct bc_volumeDump));
- tvol->name = (char *) malloc(VOLSER_MAXVOLNAME+1);
- if (!tvol->name)
- {
- com_err(whoami,BC_NOMEM,"");
+ tvol->name = (char *)malloc(VOLSER_MAXVOLNAME + 1);
+ if (!tvol->name) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
return BC_NOMEM;
}
strncpy(tvol->name, volume, VOLSER_OLDMAXVOLNAME);
memcpy(&tvol->server, &destServer, sizeof(destServer));
tvol->partition = destPartition;
- if (lastVol) lastVol->next = tvol; /* thread onto end of list */
- else volsToRestore = tvol;
+ if (lastVol)
+ lastVol->next = tvol; /* thread onto end of list */
+ else
+ volsToRestore = tvol;
lastVol = tvol;
}
fclose(fd);
- }
- else
- {
- com_err(whoami,0,"-name or -file option required");
- return(-1);
+ } else {
+ afs_com_err(whoami, 0, "-name or -file option required");
+ return (-1);
}
/* Get the port offset for the restore */
if (as->parms[2].items) {
- for (ti=as->parms[2].items; ti; ti=ti->next) portCount++;
- ports = (afs_int32 *)malloc(portCount*sizeof(afs_int32));
- if (!ports) {
- com_err(whoami,BC_NOMEM,"");
- return BC_NOMEM;
- }
+ for (ti = as->parms[2].items; ti; ti = ti->next)
+ portCount++;
+ ports = (afs_int32 *) malloc(portCount * sizeof(afs_int32));
+ if (!ports) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
+ return BC_NOMEM;
+ }
- for (ti=as->parms[2].items, i=0; ti; ti=ti->next, i++) {
- ports[i] = getPortOffset(ti->data);
- if (ports[i] < 0) return(BC_BADARG);
- }
+ for (ti = as->parms[2].items, i = 0; ti; ti = ti->next, i++) {
+ ports[i] = getPortOffset(ti->data);
+ if (ports[i] < 0)
+ return (BC_BADARG);
+ }
}
- newExt = (as->parms[3].items ? as->parms[3].items->data : NULL);
+ newExt = (as->parms[3].items ? as->parms[3].items->data : NULL);
dontExecute = (as->parms[4].items ? 1 : 0);
fromDate = 0x7fffffff; /* last one before this date */
/* Perform the call to start the restore */
code = bc_StartDmpRst(bc_globalConfig, "disk", "restore", volsToRestore,
- /*destserver*/ 0, /*destpartition*/ 0, fromDate, newExt, oldFlag,
- /*parentDump*/0, /*dumpLevel*/0,
- bc_Restorer, ports, portCount,
- /*dumpSched*/0, /*append*/0, dontExecute);
- if (code) com_err(whoami,code,"; Failed to queue restore");
+ /*destserver */ NULL, /*destpartition */ 0, fromDate,
+ newExt, oldFlag,
+ /*parentDump */ 0, /*dumpLevel */ 0,
+ bc_Restorer, ports, portCount,
+ /*dumpSched */ NULL, /*append */ 0, dontExecute);
+ if (code)
+ afs_com_err(whoami, code, "; Failed to queue restore");
return code;
}
* As advertised.
*---------------------------------------------------------------------------
*/
-int dontExecute;
-
-int bc_DumpCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
-{ /*bc_DumpCmd*/
- static char rn[] = "bc_DumpCmd"; /*Routine name*/
- char *dumpPath, *vsName; /*Ptrs to various names*/
- struct bc_volumeSet *tvs; /*Ptr to list of generated volume info*/
- struct bc_dumpSchedule *tds, *baseds; /*Ptr to dump schedule node*/
- struct bc_volumeDump *tve, *volsToDump; /*Ptr to individual vols to be dumped*/
- struct bc_volumeDump *ntve, *tves, *ptves, *rtves;
- struct budb_dumpEntry dumpEntry, de, fde; /* dump entry */
+int dontExecute;
+
+int
+bc_DumpCmd(struct cmd_syndesc *as, void *arock)
+{ /*bc_DumpCmd */
+ char *dumpPath = NULL;
+ char *vsName = NULL; /*Ptrs to various names */
+ struct bc_volumeSet *tvs = NULL; /*Ptr to list of generated volume info */
+ struct bc_dumpSchedule *tds;
+ struct bc_dumpSchedule *baseds = NULL; /*Ptr to dump schedule node */
+ struct bc_volumeDump *tve, *volsToDump; /*Ptr to individual vols to be dumped */
+ struct budb_dumpEntry dumpEntry, de, fde; /* dump entry */
afs_uint32 d;
- afs_int32 parent; /* parent dump */
- afs_int32 level; /* this dump's level # */
- afs_int32 problemFindingDump; /* can't find parent(s) */
+ afs_int32 parent; /* parent dump */
+ afs_int32 level; /* this dump's level # */
+ afs_int32 problemFindingDump; /* can't find parent(s) */
afs_int32 *portp = NULL;
- afs_int32 portCount = 0;
- afs_int32 doAt, atTime; /* Time a timed-dump is to start at */
+ afs_int32 doAt, atTime; /* Time a timed-dump is to start at */
afs_int32 length;
char *timeString;
- int doAppend; /* Append the dump to dump set */
- afs_int32 code; /* Return code */
- int loadfile; /* whether to load a file or not */
+ int doAppend = 0; /* Append the dump to dump set */
+ afs_int32 code; /* Return code */
+ int loadfile; /* whether to load a file or not */
- struct bc_dumpTask *dumpTaskPtr; /* for dump thread */
- afs_int32 dumpTaskSlot;
- char *junk;
statusP statusPtr;
- int r, nservers, ns, serverfound;
extern struct bc_dumpTask bc_dumpTasks[];
- extern afs_int32 bcdb_FindLastVolClone();
- extern afs_int32 volImageTime();
code = bc_UpdateDumpSchedule();
if (code) {
- com_err(whoami, code, "; Can't retrieve dump schedule");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve dump schedule");
+ return (code);
}
code = bc_UpdateVolumeSet();
if (code) {
- com_err(whoami, code, "; Can't retrieve volume sets");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve volume sets");
+ return (code);
}
code = bc_UpdateHosts();
if (code) {
- com_err(whoami, code, "; Can't retrieve tape hosts");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve tape hosts");
+ return (code);
}
- /*
+ /*
* Some parameters cannot be specified together
- * The "-file" option cannot exist with the "-volume", "-dump",
- * "-portoffset", or "-append" option
+ * The "-file" option cannot exist with the "-volume", "-dump",
+ * "-portoffset", or "-append" option
*/
- if (as->parms[6].items)
- {
- loadfile = 1;
- if ( as->parms[0].items || as->parms[1].items ||
- as->parms[2].items || as->parms[4].items )
- {
- com_err(whoami,0,"Invalid option specified with -file option");
+ if (as->parms[6].items) {
+ loadfile = 1;
+ if (as->parms[0].items || as->parms[1].items || as->parms[2].items
+ || as->parms[4].items) {
+ afs_com_err(whoami, 0, "Invalid option specified with -file option");
return -1;
}
- }
- else
- {
- loadfile = 0;
- if ( !as->parms[0].items || !as->parms[1].items )
- {
- com_err(whoami,0,"Must specify volume set name and dump level name");
+ } else {
+ loadfile = 0;
+ if (!as->parms[0].items || !as->parms[1].items) {
+ afs_com_err(whoami, 0,
+ "Must specify volume set name and dump level name");
return -1;
}
}
- /*
+ /*
* Get the time we are to perform this dump
*/
- if (as->parms[3].items)
- {
- doAt = 1;
+ if (as->parms[3].items) {
+ doAt = 1;
timeString = concatParams(as->parms[3].items);
- if (!timeString) return(-1);
-
+ if (!timeString)
+ return (-1);
+
/*
* Now parse this string for the time to start.
*/
code = ktime_DateToLong(timeString, &atTime);
- free (timeString);
- if ( code )
- {
- com_err(whoami,0,"Can't parse dump start date and time");
- com_err(whoami,0,"%s", ktime_GetDateUsage());
- return(1);
+ free(timeString);
+ if (code) {
+ afs_com_err(whoami, 0, "Can't parse dump start date and time");
+ afs_com_err(whoami, 0, "%s", ktime_GetDateUsage());
+ return (1);
}
- }
- else
- doAt = 0;
-
- dontExecute = (as->parms[5].items ? 1 : 0); /* -n */
+ } else
+ doAt = 0;
- /*
+ dontExecute = (as->parms[5].items ? 1 : 0); /* -n */
+
+ /*
* If this dump is not a load file, then check the parameters.
*/
- if (!loadfile)
- { /*6*/
- vsName = as->parms[0].items->data; /* get volume set name */
- dumpPath = as->parms[1].items->data; /* get dump path */
+ if (!loadfile) { /*6 */
+ vsName = as->parms[0].items->data; /* get volume set name */
+ dumpPath = as->parms[1].items->data; /* get dump path */
/* get the port number, if one was specified */
- if (as->parms[2].items)
- {
- portCount = 1;
- portp = (afs_int32 *)malloc(sizeof(afs_int32));
- if (!portp)
- {
- com_err(whoami,BC_NOMEM,"");
+ if (as->parms[2].items) {
+ portp = (afs_int32 *) malloc(sizeof(afs_int32));
+ if (!portp) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
return BC_NOMEM;
}
*portp = getPortOffset(as->parms[2].items->data);
- if (*portp < 0) return(BC_BADARG);
+ if (*portp < 0)
+ return (BC_BADARG);
}
- doAppend = (as->parms[4].items ? 1 : 0); /* -append */
+ doAppend = (as->parms[4].items ? 1 : 0); /* -append */
/*
* Get a hold of the given volume set and dump set.
*/
tvs = bc_FindVolumeSet(bc_globalConfig, vsName);
- if (!tvs)
- {
- com_err(whoami,0, "Can't find volume set '%s' in backup database", vsName);
- return(-1);
+ if (!tvs) {
+ afs_com_err(whoami, 0,
+ "Can't find volume set '%s' in backup database", vsName);
+ return (-1);
}
baseds = bc_FindDumpSchedule(bc_globalConfig, dumpPath);
- if (!baseds)
- {
- com_err(whoami,0, "Can't find dump schedule '%s' in backup database", dumpPath);
- return(-1);
+ if (!baseds) {
+ afs_com_err(whoami, 0,
+ "Can't find dump schedule '%s' in backup database",
+ dumpPath);
+ return (-1);
}
- } /*6*/
+ }
+ /*6 */
/*
- * If given the "-at" option, then add this to the jobs list and return
+ * If given the "-at" option, then add this to the jobs list and return
* with no error.
*
* Create a status node for this timed dump.
* Fill in the time to dump and the cmd line for the dump leaving off
- * the -at option. If the -n option is there, it is scheduled with
+ * the -at option. If the -n option is there, it is scheduled with
* the Timed dump as opposed to not scheduling the time dump at all.
*/
- if ( doAt )
- {
- if ( atTime < time(0) )
- {
- com_err(whoami,0,"Time of dump is earlier then current time - not added");
- }
- else
- {
+ if (doAt) {
+ if (atTime < time(0)) {
+ afs_com_err(whoami, 0,
+ "Time of dump is earlier then current time - not added");
+ } else {
statusPtr = createStatusNode();
lock_Status();
statusPtr->scheduledDump = atTime;
/* Determine length of the dump command */
length = 0;
- length += 4; /* "dump" */
- if (loadfile)
- {
- length += 6; /* " -file" */
- length += 1 + strlen(as->parms[6].items->data); /* " <file>" */
- }
- else
- {
- /* length += 11; */ /* " -volumeset" */
- length += 1 + strlen(as->parms[0].items->data); /* " <volset> */
-
- /* length += 6; */ /* " -dump" */
- length += 1 + strlen(as->parms[1].items->data); /* " <dumpset> */
-
- if (as->parms[2].items)
- {
- /* length += 12; */ /* " -portoffset" */
- length += 1 + strlen(as->parms[2].items->data); /* " <port>" */
+ length += 4; /* "dump" */
+ if (loadfile) {
+ length += 6; /* " -file" */
+ length += 1 + strlen(as->parms[6].items->data); /* " <file>" */
+ } else {
+ /* length += 11; *//* " -volumeset" */
+ length += 1 + strlen(as->parms[0].items->data); /* " <volset> */
+
+ /* length += 6; *//* " -dump" */
+ length += 1 + strlen(as->parms[1].items->data); /* " <dumpset> */
+
+ if (as->parms[2].items) {
+ /* length += 12; *//* " -portoffset" */
+ length += 1 + strlen(as->parms[2].items->data); /* " <port>" */
}
if (as->parms[4].items)
- length += 8; /* " -append" */
+ length += 8; /* " -append" */
}
if (dontExecute)
- length += 3; /* " -n" */
- length++; /* end-of-line */
+ length += 3; /* " -n" */
+ length++; /* end-of-line */
/* Allocate status block for this timed dump */
sprintf(statusPtr->taskName, "Scheduled Dump");
- statusPtr->jobNumber = bc_jobNumber();
- statusPtr->scheduledDump = atTime;
- statusPtr->cmdLine = (char *) malloc(length);
- if (!statusPtr->cmdLine)
- {
- com_err(whoami,BC_NOMEM,"");
+ statusPtr->jobNumber = bc_jobNumber();
+ statusPtr->scheduledDump = atTime;
+ statusPtr->cmdLine = (char *)malloc(length);
+ if (!statusPtr->cmdLine) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
return BC_NOMEM;
}
-
+
/* Now reconstruct the dump command */
statusPtr->cmdLine[0] = 0;
strcat(statusPtr->cmdLine, "dump");
- if (loadfile)
- {
- strcat(statusPtr->cmdLine, " -file");
+ if (loadfile) {
+ strcat(statusPtr->cmdLine, " -file");
strcat(statusPtr->cmdLine, " ");
strcat(statusPtr->cmdLine, as->parms[6].items->data);
- }
- else
- {
- /* strcat(statusPtr->cmdLine, " -volumeset"); */
+ } else {
+ /* strcat(statusPtr->cmdLine, " -volumeset"); */
strcat(statusPtr->cmdLine, " ");
strcat(statusPtr->cmdLine, as->parms[0].items->data);
strcat(statusPtr->cmdLine, " ");
strcat(statusPtr->cmdLine, as->parms[1].items->data);
- if (as->parms[2].items)
- {
+ if (as->parms[2].items) {
/* strcat(statusPtr->cmdLine, " -portoffset"); */
strcat(statusPtr->cmdLine, " ");
strcat(statusPtr->cmdLine, as->parms[2].items->data);
strcat(statusPtr->cmdLine, " -append");
}
if (dontExecute)
- strcat(statusPtr->cmdLine, " -n");
+ strcat(statusPtr->cmdLine, " -n");
printf("Add scheduled dump as job %d\n", statusPtr->jobNumber);
- if ( (atTime > ttoken.endTime) && (ttoken.endTime != NEVERDATE) )
- com_err(whoami,0,"Warning: job %d starts after expiration of AFS token",
+ if ((atTime > tokenExpires) && (tokenExpires != NEVERDATE))
+ afs_com_err(whoami, 0,
+ "Warning: job %d starts after expiration of AFS token",
statusPtr->jobNumber);
-
+
unlock_Status();
}
- return(0);
+ return (0);
}
- /*
+ /*
* Read and execute the load file if specified. The work of reading is done
* in the main routine prior the dispatch call. loadFile and dontExecute are
* global variables so this can take place in main.
*/
- if (loadfile)
- {
- loadFile = (char *) malloc(strlen(as->parms[6].items->data)+1);
- if (!loadFile)
- {
- com_err(whoami,BC_NOMEM,"");
+ if (loadfile) {
+ loadFile = (char *)malloc(strlen(as->parms[6].items->data) + 1);
+ if (!loadFile) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
return BC_NOMEM;
}
strcpy(loadFile, as->parms[6].items->data);
return 0;
}
- /*
+ /*
* We are doing a real dump (no load file or timed dump).
*/
- printf("Starting dump of volume set '%s' (dump level '%s')\n", vsName, dumpPath);
+ printf("Starting dump of volume set '%s' (dump level '%s')\n", vsName,
+ dumpPath);
/* For each dump-level above this one, see if the volumeset was dumped
* at the level. We search all dump-levels since a higher dump-level
*/
parent = level = problemFindingDump = 0;
for (tds = baseds->parent; tds; tds = tds->parent) {
- /* Find the most recent dump of the volume-set at this dump-level.
+ /* Find the most recent dump of the volume-set at this dump-level.
* Raise problem flag if didn't find a dump and a parent not yet found.
*/
- code = bcdb_FindLatestDump(vsName, tds->name, &dumpEntry);
+ code = bcdb_FindLatestDump(vsName, tds->name, &dumpEntry);
if (code) {
- if (!parent) problemFindingDump = 1; /* skipping a dump level */
- continue;
+ if (!parent)
+ problemFindingDump = 1; /* skipping a dump level */
+ continue;
}
/* We found the most recent dump at this level. Now check
- * if we should use it by seeing if its full dump hierarchy
+ * if we should use it by seeing if its full dump hierarchy
* exists. If it doesn't, we don't want to base our incremental
- * off of this dump.
+ * off of this dump.
*/
if (!parent || (dumpEntry.id > parent)) {
- /* Follow the parent dumps to see if they are all there */
- for (d=dumpEntry.parent; d; d=de.parent) {
- code = bcdb_FindDumpByID(d, &de);
- if (code) break;
+ /* Follow the parent dumps to see if they are all there */
+ for (d = dumpEntry.parent; d; d = de.parent) {
+ code = bcdb_FindDumpByID(d, &de);
+ if (code)
+ break;
}
/* If we found the entire level, remember it. Otherwise raise flag.
* If we had already found a dump, raise the problem flag.
*/
if (!d && !code) {
- if (parent) problemFindingDump = 1;
- parent = dumpEntry.id;
- level = dumpEntry.level+1;
- memcpy(&fde, &dumpEntry, sizeof(dumpEntry));
- }
- else {
- /* Dump hierarchy not complete so can't base off the latest */
- problemFindingDump = 1;
+ if (parent)
+ problemFindingDump = 1;
+ parent = dumpEntry.id;
+ level = dumpEntry.level + 1;
+ memcpy(&fde, &dumpEntry, sizeof(dumpEntry));
+ } else {
+ /* Dump hierarchy not complete so can't base off the latest */
+ problemFindingDump = 1;
}
}
}
-
- /* If the problemflag was raise, it means we are not doing the
+
+ /* If the problemflag was raise, it means we are not doing the
* dump at the level we requested it be done at.
*/
if (problemFindingDump) {
- com_err(whoami,0,
- "Warning: Doing level %d dump due to missing higher-level dumps", level);
- if (parent) {
- printf("Parent dump: dump %s (DumpID %u)\n", fde.name, parent);
- }
- }
- else if (parent) {
- printf("Found parent: dump %s (DumpID %u)\n", fde.name, parent);
+ afs_com_err(whoami, 0,
+ "Warning: Doing level %d dump due to missing higher-level dumps",
+ level);
+ if (parent) {
+ printf("Parent dump: dump %s (DumpID %u)\n", fde.name, parent);
+ }
+ } else if (parent) {
+ printf("Found parent: dump %s (DumpID %u)\n", fde.name, parent);
}
/* Expand out the volume set into its component list of volumes. */
code = bc_EvalVolumeSet(bc_globalConfig, tvs, &volsToDump, cstruct);
- if (code)
- {
- com_err(whoami,code,"; Failed to evaluate volume set");
- return(-1);
+ if (code) {
+ afs_com_err(whoami, code, "; Failed to evaluate volume set");
+ return (-1);
}
- if (!volsToDump)
- {
- printf("No volumes to dump\n");
- return(0);
+ if (!volsToDump) {
+ printf("No volumes to dump\n");
+ return (0);
}
/* Determine what the clone time of the volume was when it was
* last dumped (tve->date). This is the time from when an
* incremental should be done (remains zero if a full dump).
*/
- if (parent)
- {
- for (tve=volsToDump; tve; tve=tve->next)
- {
+ if (parent) {
+ for (tve = volsToDump; tve; tve = tve->next) {
code = bcdb_FindClone(parent, tve->name, &tve->date);
- if (code) tve->date = 0;
+ if (code)
+ tve->date = 0;
/* Get the time the volume was last cloned and see if the volume has
* changed since then. Only do this when the "-n" flag is specified
* because butc will get the cloneDate at time of dump.
*/
- if (dontExecute)
- {
- code = volImageTime(tve->server.sin_addr.s_addr, tve->partition,
- tve->vid, tve->volType, &tve->cloneDate);
- if (code) tve->cloneDate = 0;
-
- if (tve->cloneDate && (tve->cloneDate == tve->date))
- {
- com_err(whoami,0,
+ if (dontExecute) {
+ code =
+ volImageTime(tve->server.sin_addr.s_addr, tve->partition,
+ tve->vid, tve->volType, &tve->cloneDate);
+ if (code)
+ tve->cloneDate = 0;
+
+ if (tve->cloneDate && (tve->cloneDate == tve->date)) {
+ afs_com_err(whoami, 0,
"Warning: Timestamp on volume %s unchanged from previous dump",
tve->name);
}
}
}
- if (dontExecute) printf("Would have dumped the following volumes:\n");
- else printf("Preparing to dump the following volumes:\n");
- for (tve=volsToDump; tve; tve=tve->next) {
- printf("\t%s (%u)\n", tve->name, tve->vid);
- }
- if (dontExecute) return(0);
-
- code = bc_StartDmpRst(bc_globalConfig, dumpPath, vsName, volsToDump,
- /*destServer*/0, /*destPartition*/0, /*fromDate*/0,
- /*newExt*/0, /*oldFlag*/0,
- parent, level, bc_Dumper, portp, /*portCount*/1, baseds,
- doAppend, dontExecute);
- if (code) com_err(whoami,code,"; Failed to queue dump");
+ if (dontExecute)
+ printf("Would have dumped the following volumes:\n");
+ else
+ printf("Preparing to dump the following volumes:\n");
+ for (tve = volsToDump; tve; tve = tve->next) {
+ printf("\t%s (%u)\n", tve->name, tve->vid);
+ }
+ if (dontExecute)
+ return (0);
+
+ code = bc_StartDmpRst(bc_globalConfig, dumpPath, vsName, volsToDump,
+ /*destServer */ NULL, /*destPartition */ 0,
+ /*fromDate */ 0,
+ /*newExt */ NULL, /*oldFlag */ 0,
+ parent, level, bc_Dumper, portp, /*portCount */ 1,
+ baseds, doAppend, dontExecute);
+ if (code)
+ afs_com_err(whoami, code, "; Failed to queue dump");
- return(code);
-} /*bc_DumpCmd*/
+ return (code);
+} /*bc_DumpCmd */
/* bc_QuitCmd
* parameters:
* ignored
*/
-
-bc_QuitCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_QuitCmd(struct cmd_syndesc *as, void *arock)
{
- int i;
- struct bc_dumpTask *td;
- extern dlqlinkT statusHead;
- dlqlinkP ptr;
- statusP statusPtr;
+ int i;
+ struct bc_dumpTask *td;
+ extern dlqlinkT statusHead;
+ dlqlinkP ptr;
+ statusP statusPtr;
/* Check the status list for outstanding jobs */
lock_Status();
- for ( ptr=(&statusHead)->dlq_next; ptr!=&statusHead; ptr=ptr->dlq_next )
- {
- statusPtr = (statusP) ptr;
- if ( !(statusPtr->flags & ABORT_REQUEST) )
- {
+ for (ptr = (&statusHead)->dlq_next; ptr != &statusHead;
+ ptr = ptr->dlq_next) {
+ statusPtr = (statusP) ptr;
+ if (!(statusPtr->flags & ABORT_REQUEST)) {
unlock_Status();
- com_err(whoami,0,"Job %d still running (and not aborted)", statusPtr->jobNumber);
- com_err(whoami,0,"You must at least 'kill' all running jobs before quitting");
+ afs_com_err(whoami, 0, "Job %d still running (and not aborted)",
+ statusPtr->jobNumber);
+ afs_com_err(whoami, 0,
+ "You must at least 'kill' all running jobs before quitting");
return -1;
}
}
/* A job still being initialized (but no status structure or job number since it
* has not been handed to a butc process yet)
*/
- for(td=bc_dumpTasks, i=0; i<BC_MAXSIMDUMPS; i++, td++)
- {
- if (td->flags & BC_DI_INUSE)
- {
- com_err(whoami,0,"A job is still running");
- com_err(whoami,0,"You must at least 'kill' all running jobs before quitting");
+ for (td = bc_dumpTasks, i = 0; i < BC_MAXSIMDUMPS; i++, td++) {
+ if (td->flags & BC_DI_INUSE) {
+ afs_com_err(whoami, 0, "A job is still running");
+ afs_com_err(whoami, 0,
+ "You must at least 'kill' all running jobs before quitting");
return -1;
}
}
#ifdef AFS_NT40_ENV
/* close the all temp text files before quitting */
- for(i=0; i<TB_NUM; i++)
- bc_closeTextFile(&bc_globalConfig->configText[i], &bc_globalConfig->tmpTextFileNames[i][0]);
+ for (i = 0; i < TB_NUM; i++)
+ bc_closeTextFile(&bc_globalConfig->configText[i],
+ &bc_globalConfig->tmpTextFileNames[i][0]);
#endif
exit(lastTaskCode);
}
* Labels a tape i.e. request the tape coordinator to perform this
* operation
*/
-
-bc_LabelTapeCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_LabelTapeCmd(struct cmd_syndesc *as, void *arock)
{
- char *tapename=0, *pname=0;
+ char *tapename = 0, *pname = 0;
afs_int32 size;
afs_int32 code;
afs_int32 port = 0;
code = bc_UpdateHosts();
if (code) {
- com_err(whoami, code, "; Can't retrieve tape hosts");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve tape hosts");
+ return (code);
}
- if(as->parms[0].items) { /* -name */
- tapename = as->parms[0].items->data;
- if (strlen(tapename) >= TC_MAXTAPELEN) {
- com_err(whoami,0,"AFS tape name '%s' is too long", tapename);
+ if (as->parms[0].items) { /* -name */
+ tapename = as->parms[0].items->data;
+ if (strlen(tapename) >= TC_MAXTAPELEN) {
+ afs_com_err(whoami, 0, "AFS tape name '%s' is too long", tapename);
return -1;
- }
+ }
}
- if(as->parms[3].items) { /* -pname */
- if (tapename) {
- com_err(whoami, 0, "Can only specify -name or -pname");
+ if (as->parms[3].items) { /* -pname */
+ if (tapename) {
+ afs_com_err(whoami, 0, "Can only specify -name or -pname");
return -1;
- }
- pname = as->parms[3].items->data;
- if (strlen(pname) >= TC_MAXTAPELEN) {
- com_err(whoami,0,"Permanent tape name '%s' is too long", pname);
+ }
+ pname = as->parms[3].items->data;
+ if (strlen(pname) >= TC_MAXTAPELEN) {
+ afs_com_err(whoami, 0, "Permanent tape name '%s' is too long", pname);
return -1;
- }
+ }
}
- if (as->parms[1].items)
- {
+ if (as->parms[1].items) {
size = bc_FloatATOI(as->parms[1].items->data);
if (size == -1) {
- com_err(whoami,0,"Bad syntax for tape size '%s'",
+ afs_com_err(whoami, 0, "Bad syntax for tape size '%s'",
as->parms[1].items->data);
return -1;
}
- }
- else
+ } else
size = 0;
- if (as->parms[2].items)
- {
- port = getPortOffset(as->parms[2].items->data);
- if (port < 0) return(BC_BADARG);
+ if (as->parms[2].items) {
+ port = getPortOffset(as->parms[2].items->data);
+ if (port < 0)
+ return (BC_BADARG);
}
code = bc_LabelTape(tapename, pname, size, bc_globalConfig, port);
- if (code) return code;
+ if (code)
+ return code;
return 0;
}
* params:
* optional port number
*/
-
-bc_ReadLabelCmd(as, arock)
-struct cmd_syndesc *as;
-char *arock;
+int
+bc_ReadLabelCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
afs_int32 port = 0;
-
+
code = bc_UpdateHosts();
if (code) {
- com_err(whoami, code, "; Can't retrieve tape hosts");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve tape hosts");
+ return (code);
}
if (as->parms[0].items) {
- port = getPortOffset(as->parms[0].items->data);
- if (port < 0) return(BC_BADARG);
+ port = getPortOffset(as->parms[0].items->data);
+ if (port < 0)
+ return (BC_BADARG);
}
code = bc_ReadLabel(bc_globalConfig, port);
- if (code) return code;
+ if (code)
+ return code;
return 0;
}
* read content information from dump tapes, and if user desires,
* add it to the database
*/
-
-bc_ScanDumpsCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_ScanDumpsCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 port = 0;
afs_int32 dbAddFlag = 0;
code = bc_UpdateHosts();
if (code) {
- com_err(whoami, code, "; Can't retrieve tape hosts");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve tape hosts");
+ return (code);
}
/* check for flag */
- if ( as->parms[0].items != 0 ) /* add scan to database */
- {
- dbAddFlag++;
+ if (as->parms[0].items != 0) { /* add scan to database */
+ dbAddFlag++;
}
/* check for port */
if (as->parms[1].items) {
- port = getPortOffset(as->parms[1].items->data);
- if (port < 0) return(BC_BADARG);
+ port = getPortOffset(as->parms[1].items->data);
+ if (port < 0)
+ return (BC_BADARG);
}
code = bc_ScanDumps(bc_globalConfig, dbAddFlag, port);
*/
afs_int32
-bc_ParseExpiration(paramPtr, expType, expDate)
- struct cmd_parmdesc *paramPtr;
- afs_int32 *expType;
- afs_int32 *expDate;
+bc_ParseExpiration(struct cmd_parmdesc *paramPtr, afs_int32 *expType,
+ afs_int32 *expDate)
{
- struct cmd_item *itemPtr;
- struct ktime_date kt;
- char *dateString = 0;
- afs_int32 code = 0;
-
- *expType = BC_NO_EXPDATE;
- *expDate = 0;
-
- if ( !paramPtr->items ) ERROR(0); /* no expiration specified */
-
- /* some form of expiration date specified. First validate the prefix */
- itemPtr = paramPtr->items;
-
- if ( strcmp(itemPtr->data, "at") == 0 )
- {
- *expType = BC_ABS_EXPDATE;
-
- dateString = concatParams(itemPtr->next);
- if (!dateString) ERROR(1);
-
- code = ktime_DateToLong(dateString, expDate);
- if (code) ERROR(1);
- }
- else
- if ( strcmp(itemPtr->data, "in") == 0 )
- {
- *expType = BC_REL_EXPDATE;
-
- dateString = concatParams(itemPtr->next);
- if (!dateString) ERROR(1);
-
- code = ParseRelDate(dateString, &kt);
- if (code) ERROR(1);
- *expDate = ktimeRelDate_ToLong(&kt);
- }
- else
- {
- dateString = concatParams(itemPtr);
- if (!dateString) ERROR(1);
-
- if ( ktime_DateToLong(dateString,expDate) == 0 )
- {
- *expType = BC_ABS_EXPDATE;
- code = ktime_DateToLong(dateString, expDate);
- if (code) ERROR(1);
- }
- else if ( ParseRelDate(dateString,&kt) == 0 )
- {
- *expType = BC_REL_EXPDATE;
- *expDate = ktimeRelDate_ToLong(&kt);
- }
- else
- {
- ERROR(1);
- }
- }
-
-error_exit:
- if (dateString) free(dateString);
- return(code);
+ struct cmd_item *itemPtr;
+ struct ktime_date kt;
+ char *dateString = 0;
+ afs_int32 code = 0;
+
+ *expType = BC_NO_EXPDATE;
+ *expDate = 0;
+
+ if (!paramPtr->items)
+ ERROR(0); /* no expiration specified */
+
+ /* some form of expiration date specified. First validate the prefix */
+ itemPtr = paramPtr->items;
+
+ if (strcmp(itemPtr->data, "at") == 0) {
+ *expType = BC_ABS_EXPDATE;
+
+ dateString = concatParams(itemPtr->next);
+ if (!dateString)
+ ERROR(1);
+
+ code = ktime_DateToLong(dateString, expDate);
+ if (code)
+ ERROR(1);
+ } else if (strcmp(itemPtr->data, "in") == 0) {
+ *expType = BC_REL_EXPDATE;
+
+ dateString = concatParams(itemPtr->next);
+ if (!dateString)
+ ERROR(1);
+
+ code = ParseRelDate(dateString, &kt);
+ if (code)
+ ERROR(1);
+ *expDate = ktimeRelDate_ToLong(&kt);
+ } else {
+ dateString = concatParams(itemPtr);
+ if (!dateString)
+ ERROR(1);
+
+ if (ktime_DateToLong(dateString, expDate) == 0) {
+ *expType = BC_ABS_EXPDATE;
+ code = ktime_DateToLong(dateString, expDate);
+ if (code)
+ ERROR(1);
+ } else if (ParseRelDate(dateString, &kt) == 0) {
+ *expType = BC_REL_EXPDATE;
+ *expDate = ktimeRelDate_ToLong(&kt);
+ } else {
+ ERROR(1);
+ }
+ }
+
+ error_exit:
+ if (dateString)
+ free(dateString);
+ return (code);
}
/* database lookup command and routines */
* Currently a single option, volumename to search for. Reports
* all dumps containing the specified volume
*/
-
-bc_dblookupCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_dblookupCmd(struct cmd_syndesc *as, void *arock)
{
struct cmd_item *ciptr;
afs_int32 code;
ciptr = as->parms[0].items;
- if ( ciptr == 0 ) /* no argument specified */
- return(-1);
+ if (ciptr == 0) /* no argument specified */
+ return (-1);
code = DBLookupByVolume(ciptr->data);
- return(code);
+ return (code);
}
/* for ubik version */
-
-bc_dbVerifyCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_dbVerifyCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 status;
afs_int32 orphans;
afs_int32 host;
struct hostent *hostPtr;
- int detail;
+ int detail;
afs_int32 code = 0;
extern struct udbHandleS udbHandle;
-
- detail = (as->parms[0].items ? 1 : 0); /* print more details */
- code = ubik_Call(BUDB_DbVerify, udbHandle.uh_client, 0,
- &status, &orphans, &host);
+ detail = (as->parms[0].items ? 1 : 0); /* print more details */
- if (code)
- {
- com_err(whoami, code, "; Unable to verify database");
- return(-1);
+ code =
+ ubik_BUDB_DbVerify(udbHandle.uh_client, 0, &status, &orphans,
+ &host);
+
+ if (code) {
+ afs_com_err(whoami, code, "; Unable to verify database");
+ return (-1);
}
/* verification call succeeded */
-
+
if (status == 0)
printf("Database OK\n");
else
- com_err(whoami, status, "; Database is NOT_OK");
+ afs_com_err(whoami, status, "; Database is NOT_OK");
- if (detail)
- {
+ if (detail) {
printf("Orphan blocks %d\n", orphans);
if (!host)
printf("Unable to lookup host id\n");
- else
- {
- hostPtr = gethostbyaddr((char *) &host, sizeof(host), AF_INET);
- if (hostPtr == 0 )
- printf("Database checker was %d.%d.%d.%d\n",
- ((host&0xFF000000)>>24), ((host&0xFF0000)>>16),
- ((host&0xFF00)>>8), (host&0xFF));
+ else {
+ hostPtr = gethostbyaddr((char *)&host, sizeof(host), AF_INET);
+ if (hostPtr == 0)
+ printf("Database checker was %d.%d.%d.%d\n",
+ ((host & 0xFF000000) >> 24), ((host & 0xFF0000) >> 16),
+ ((host & 0xFF00) >> 8), (host & 0xFF));
else
- printf("Database checker was %s\n", hostPtr->h_name);
+ printf("Database checker was %s\n", hostPtr->h_name);
}
}
- return((status ? -1 : 0));
+ return ((status ? -1 : 0));
}
/* deleteDump:
* Delete a dump. If port is >= 0, it means try to delete from XBSA server
*/
-deleteDump(dumpid, port, force)
- afs_uint32 dumpid; /* The dumpid to delete */
- afs_int32 port; /* port==-1 means don't go to butc */
- afs_int32 force;
+int
+deleteDump(afs_uint32 dumpid, /* The dumpid to delete */
+ afs_int32 port, /* port==-1 means don't go to butc */
+ afs_int32 force)
{
- afs_int32 code=0, tcode;
- struct budb_dumpEntry dumpEntry;
- struct rx_connection *tconn=0;
- afs_int32 i, taskflag, xbsadump;
- statusP statusPtr=0;
- budb_dumpsList dumps;
- afs_uint32 taskId;
-
- /* If the port is set, we will try to send a delete request to the butc */
- if (port >= 0) {
- tcode = bc_UpdateHosts();
- if (tcode) {
- com_err(whoami, tcode, "; Can't retrieve tape hosts");
- ERROR(tcode);
- }
+ afs_int32 code = 0, tcode;
+ struct budb_dumpEntry dumpEntry;
+ struct rx_connection *tconn = 0;
+ afs_int32 i, taskflag, xbsadump;
+ statusP statusPtr = 0;
+ budb_dumpsList dumps;
+ afs_uint32 taskId;
- /* Find the dump in the backup database */
- tcode = bcdb_FindDumpByID(dumpid, &dumpEntry);
- if (tcode) {
- com_err(whoami, tcode, "; Unable to locate dumpID %u in database", dumpid);
- ERROR(tcode);
- }
- xbsadump = (dumpEntry.flags & (BUDB_DUMP_ADSM|BUDB_DUMP_BUTA));
-
- /* If dump is to an XBSA server, connect to butc and send it
- * the dump to delete. Butc will contact the XBSA server.
- * The dump will not be an appended dump because XBSA butc
- * does not support the append option.
- */
- if (xbsadump && dumpEntry.nVolumes) {
- tcode = ConnectButc(bc_globalConfig, port, &tconn);
- if (tcode) ERROR(tcode);
-
- tcode = TC_DeleteDump(tconn, dumpid, &taskId);
- if (tcode) {
- if (tcode == RXGEN_OPCODE) tcode = BC_VERSIONFAIL;
- com_err(whoami, tcode, "; Unable to delete dumpID %u via butc", dumpid);
+ /* If the port is set, we will try to send a delete request to the butc */
+ if (port >= 0) {
+ tcode = bc_UpdateHosts();
+ if (tcode) {
+ afs_com_err(whoami, tcode, "; Can't retrieve tape hosts");
ERROR(tcode);
- }
-
- statusPtr = createStatusNode();
- lock_Status();
- statusPtr->taskId = taskId;
- statusPtr->port = port;
- statusPtr->jobNumber = bc_jobNumber();
- statusPtr->flags |= (SILENT|NOREMOVE); /* No msg & keep statusPtr */
- statusPtr->flags &= ~STARTING; /* clearstatus to examine */
- sprintf(statusPtr->taskName, "DeleteDump");
- unlock_Status();
-
- /* Wait for task to finish */
- taskflag = waitForTask(taskId);
- if (taskflag & (TASK_ERROR|ABORT_DONE)) {
- com_err(whoami, BUTX_DELETEOBJFAIL, "; Unable to delete dumpID %u via butc", dumpid);
- ERROR(BUTX_DELETEOBJFAIL); /* the task failed */
- }
- }
- }
+ }
+
+ /* Find the dump in the backup database */
+ tcode = bcdb_FindDumpByID(dumpid, &dumpEntry);
+ if (tcode) {
+ afs_com_err(whoami, tcode, "; Unable to locate dumpID %u in database",
+ dumpid);
+ ERROR(tcode);
+ }
+ xbsadump = (dumpEntry.flags & (BUDB_DUMP_ADSM | BUDB_DUMP_BUTA));
+
+ /* If dump is to an XBSA server, connect to butc and send it
+ * the dump to delete. Butc will contact the XBSA server.
+ * The dump will not be an appended dump because XBSA butc
+ * does not support the append option.
+ */
+ if (xbsadump && dumpEntry.nVolumes) {
+ tcode = ConnectButc(bc_globalConfig, port, &tconn);
+ if (tcode)
+ ERROR(tcode);
+
+ tcode = TC_DeleteDump(tconn, dumpid, &taskId);
+ if (tcode) {
+ if (tcode == RXGEN_OPCODE)
+ tcode = BC_VERSIONFAIL;
+ afs_com_err(whoami, tcode,
+ "; Unable to delete dumpID %u via butc", dumpid);
+ ERROR(tcode);
+ }
+
+ statusPtr = createStatusNode();
+ lock_Status();
+ statusPtr->taskId = taskId;
+ statusPtr->port = port;
+ statusPtr->jobNumber = bc_jobNumber();
+ statusPtr->flags |= (SILENT | NOREMOVE); /* No msg & keep statusPtr */
+ statusPtr->flags &= ~STARTING; /* clearstatus to examine */
+ sprintf(statusPtr->taskName, "DeleteDump");
+ unlock_Status();
+
+ /* Wait for task to finish */
+ taskflag = waitForTask(taskId);
+ if (taskflag & (TASK_ERROR | ABORT_DONE)) {
+ afs_com_err(whoami, BUTX_DELETEOBJFAIL,
+ "; Unable to delete dumpID %u via butc", dumpid);
+ ERROR(BUTX_DELETEOBJFAIL); /* the task failed */
+ }
+ }
+ }
error_exit:
- if (statusPtr) deleteStatusNode(statusPtr); /* Clean up statusPtr - because NOREMOVE */
- if (tconn) rx_DestroyConnection(tconn); /* Destroy the connection */
-
- /* Remove the dump from the backup database */
- if (!code || force) {
- dumps.budb_dumpsList_len = 0;
- dumps.budb_dumpsList_val = 0;
-
- tcode = bcdb_deleteDump(dumpid, 0, 0, &dumps);
- if (tcode) {
- com_err(whoami, tcode, "; Unable to delete dumpID %u from database", dumpid);
- dumps.budb_dumpsList_len = 0;
- if (!code) code = tcode;
- }
+ if (statusPtr)
+ deleteStatusNode(statusPtr); /* Clean up statusPtr - because NOREMOVE */
+ if (tconn)
+ rx_DestroyConnection(tconn); /* Destroy the connection */
+
+ /* Remove the dump from the backup database */
+ if (!code || force) {
+ dumps.budb_dumpsList_len = 0;
+ dumps.budb_dumpsList_val = 0;
- /* Display the dumps that were deleted - includes appended dumps */
- for (i=0; i<dumps.budb_dumpsList_len; i++)
- printf(" %u%s\n", dumps.budb_dumpsList_val[i],
- (i>0)?" Appended Dump":"");
- if (dumps.budb_dumpsList_val) free(dumps.budb_dumpsList_val);
- }
+ tcode = bcdb_deleteDump(dumpid, 0, 0, &dumps);
+ if (tcode) {
+ afs_com_err(whoami, tcode,
+ "; Unable to delete dumpID %u from database", dumpid);
+ dumps.budb_dumpsList_len = 0;
+ if (!code)
+ code = tcode;
+ }
+
+ /* Display the dumps that were deleted - includes appended dumps */
+ for (i = 0; i < dumps.budb_dumpsList_len; i++)
+ printf(" %u%s\n", dumps.budb_dumpsList_val[i],
+ (i > 0) ? " Appended Dump" : NULL);
+ if (dumps.budb_dumpsList_val)
+ free(dumps.budb_dumpsList_val);
+ }
- return code;
+ return code;
}
/* bc_deleteDumpCmd
* entry:
* dump id - single required arg as param 0.
*/
-
-bc_deleteDumpCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_deleteDumpCmd(struct cmd_syndesc *as, void *arock)
{
afs_uint32 dumpid;
- afs_int32 code = 0;
+ afs_int32 code = 0;
afs_int32 rcode = 0;
- afs_int32 groupId=0, havegroupid, sflags, noexecute;
+ afs_int32 groupId = 0, havegroupid, sflags, noexecute;
struct cmd_item *ti;
- afs_uint32 fromTime=0, toTime=0, havetime=0;
- char *timeString;
+ afs_int32 fromTime = 0, toTime = 0, havetime = 0;
+ char *timeString;
budb_dumpsList dumps, flags;
int i;
- afs_int32 port=-1, dbonly=0, force;
- afs_uint32 taskid;
+ afs_int32 port = -1, force;
/* Must specify at least one of -dumpid, -from, or -to */
- if ( !as->parms[0].items && !as->parms[1].items && !as->parms[2].items &&
- !as->parms[4].items) {
- com_err(whoami, 0, "Must specify at least one field");
- return(-1);
+ if (!as->parms[0].items && !as->parms[1].items && !as->parms[2].items
+ && !as->parms[4].items) {
+ afs_com_err(whoami, 0, "Must specify at least one field");
+ return (-1);
}
/* Must have -to option with -from option */
- if ( as->parms[1].items && !as->parms[2].items ) {
- com_err(whoami, 0, "Must specify '-to' field with '-from' field");
- return(-1);
+ if (as->parms[1].items && !as->parms[2].items) {
+ afs_com_err(whoami, 0, "Must specify '-to' field with '-from' field");
+ return (-1);
}
/* Get the time to delete from */
- if ( as->parms[1].items ) { /* -from */
+ if (as->parms[1].items) { /* -from */
timeString = concatParams(as->parms[1].items);
- if (!timeString) return(-1);
+ if (!timeString)
+ return (-1);
/*
* Now parse this string for the time to start.
*/
code = ktime_DateToLong(timeString, &fromTime);
- free (timeString);
- if ( code )
- {
- com_err(whoami,0,"Can't parse 'from' date and time");
- com_err(whoami,0,"%s", ktime_GetDateUsage());
- return(-1);
+ free(timeString);
+ if (code) {
+ afs_com_err(whoami, 0, "Can't parse 'from' date and time");
+ afs_com_err(whoami, 0, "%s", ktime_GetDateUsage());
+ return (-1);
}
havetime = 1;
}
- port = (as->parms[3].items ? getPortOffset(as->parms[3].items->data) : 0); /* -port */
- if (as->parms[5].items) /* -dbonly */
- port = -1;
-
- force = (as->parms[6].items ? 1 : 0);
+ port = (as->parms[3].items ? getPortOffset(as->parms[3].items->data) : 0); /* -port */
+ if (as->parms[5].items) /* -dbonly */
+ port = -1;
+
+ force = (as->parms[6].items ? 1 : 0);
- havegroupid = (as->parms[4].items ? 1 : 0);
- if (havegroupid) groupId = atoi(as->parms[4].items->data);
+ havegroupid = (as->parms[4].items ? 1 : 0);
+ if (havegroupid)
+ groupId = atoi(as->parms[4].items->data);
- noexecute = (as->parms[7].items ? 1 : 0);
+ noexecute = (as->parms[7].items ? 1 : 0);
/* Get the time to delete to */
- if ( as->parms[2].items ) { /* -to */
+ if (as->parms[2].items) { /* -to */
timeString = concatParams(as->parms[2].items);
- if (!timeString) return(-1);
+ if (!timeString)
+ return (-1);
/*
* Now parse this string for the time to start. Simce
* times are at minute granularity, add 59 seconds.
*/
code = ktime_DateToLong(timeString, &toTime);
- free (timeString);
- if ( code )
- {
- com_err(whoami,0,"Can't parse 'to' date and time");
- com_err(whoami,0,"%s", ktime_GetDateUsage());
- return(-1);
+ free(timeString);
+ if (code) {
+ afs_com_err(whoami, 0, "Can't parse 'to' date and time");
+ afs_com_err(whoami, 0, "%s", ktime_GetDateUsage());
+ return (-1);
}
toTime += 59;
havetime = 1;
}
- if ( fromTime > toTime ) {
- com_err(whoami, 0, "'-from' date/time cannot be later than '-to' date/time");
- return(-1);
+ if (fromTime > toTime) {
+ afs_com_err(whoami, 0,
+ "'-from' date/time cannot be later than '-to' date/time");
+ return (-1);
}
/* Remove speicific dump ids - if any */
- printf("The following dumps %s deleted:\n", (noexecute?"would have been":"were"));
- for ( ti=as->parms[0].items; ti != 0; ti=ti->next ) { /* -dumpid */
- dumpid = atoi(ti->data);
+ printf("The following dumps %s deleted:\n",
+ (noexecute ? "would have been" : "were"));
+ for (ti = as->parms[0].items; ti != 0; ti = ti->next) { /* -dumpid */
+ dumpid = atoi(ti->data);
if (!noexecute) {
- code = deleteDump(dumpid, port, force);
+ code = deleteDump(dumpid, port, force);
} else {
- printf(" %u\n", dumpid);
+ printf(" %u\n", dumpid);
}
}
flags.budb_dumpsList_len = 0;
flags.budb_dumpsList_val = 0;
sflags = 0;
- if (havegroupid) sflags |= BUDB_OP_GROUPID;
- if (havetime) sflags |= BUDB_OP_DATES;
+ if (havegroupid)
+ sflags |= BUDB_OP_GROUPID;
+ if (havetime)
+ sflags |= BUDB_OP_DATES;
- code = bcdb_listDumps(sflags, groupId, fromTime, toTime, &dumps, &flags);
- if ( code ) {
- com_err(whoami, code, "; Error while deleting dumps from %u to %u",
- fromTime, toTime);
+ code =
+ bcdb_listDumps(sflags, groupId, fromTime, toTime, &dumps, &flags);
+ if (code) {
+ afs_com_err(whoami, code,
+ "; Error while deleting dumps from %u to %u", fromTime,
+ toTime);
rcode = -1;
}
- for (i=0; i<dumps.budb_dumpsList_len; i++) {
- if (flags.budb_dumpsList_val[i] & BUDB_OP_DBDUMP) continue;
+ for (i = 0; i < dumps.budb_dumpsList_len; i++) {
+ if (flags.budb_dumpsList_val[i] & BUDB_OP_DBDUMP)
+ continue;
- if (!noexecute) {
- if (flags.budb_dumpsList_val[i] & BUDB_OP_APPDUMP) continue;
- code = deleteDump(dumps.budb_dumpsList_val[i], port, force);
- /* Ignore code and continue */
- } else {
- printf(" %u%s%s\n", dumps.budb_dumpsList_val[i],
- (flags.budb_dumpsList_val[i] & BUDB_OP_APPDUMP)?" Appended Dump":"",
- (flags.budb_dumpsList_val[i] & BUDB_OP_DBDUMP) ?" Database Dump":"");
+ if (!noexecute) {
+ if (flags.budb_dumpsList_val[i] & BUDB_OP_APPDUMP)
+ continue;
+ code = deleteDump(dumps.budb_dumpsList_val[i], port, force);
+ /* Ignore code and continue */
+ } else {
+ printf(" %u%s%s\n", dumps.budb_dumpsList_val[i],
+ (flags.
+ budb_dumpsList_val[i] & BUDB_OP_APPDUMP) ?
+ " Appended Dump" : "",
+ (flags.
+ budb_dumpsList_val[i] & BUDB_OP_DBDUMP) ?
+ " Database Dump" : "");
- }
+ }
}
- if (dumps.budb_dumpsList_val) free(dumps.budb_dumpsList_val);
+ if (dumps.budb_dumpsList_val)
+ free(dumps.budb_dumpsList_val);
dumps.budb_dumpsList_len = 0;
dumps.budb_dumpsList_val = 0;
- if (flags.budb_dumpsList_val) free(flags.budb_dumpsList_val);
+ if (flags.budb_dumpsList_val)
+ free(flags.budb_dumpsList_val);
flags.budb_dumpsList_len = 0;
flags.budb_dumpsList_val = 0;
}
- return(rcode);
+ return (rcode);
}
-bc_saveDbCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_saveDbCmd(struct cmd_syndesc *as, void *arock)
{
struct rx_connection *tconn;
- afs_int32 portOffset = 0;
+ afs_int32 portOffset = 0;
statusP statusPtr;
- afs_uint32 taskId;
- afs_int32 code;
- afs_uint32 toTime;
- char *timeString;
+ afs_uint32 taskId;
+ afs_int32 code;
+ afs_uint32 toTime;
+ char *timeString;
code = bc_UpdateHosts();
if (code) {
- com_err(whoami, code, "; Can't retrieve tape hosts");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve tape hosts");
+ return (code);
}
if (as->parms[0].items) {
portOffset = getPortOffset(as->parms[0].items->data);
- if (portOffset < 0) return(BC_BADARG);
+ if (portOffset < 0)
+ return (BC_BADARG);
}
/* Get the time to delete to */
- if ( as->parms[1].items )
- {
+ if (as->parms[1].items) {
timeString = concatParams(as->parms[1].items);
- if (!timeString) return(-1);
+ if (!timeString)
+ return (-1);
/*
* Now parse this string for the time. Since
* times are at minute granularity, add 59 seconds.
*/
code = ktime_DateToLong(timeString, &toTime);
- free (timeString);
- if ( code )
- {
- com_err(whoami,0,"Can't parse '-archive' date and time");
- com_err(whoami,0,"%s", ktime_GetDateUsage());
- return(-1);
+ free(timeString);
+ if (code) {
+ afs_com_err(whoami, 0, "Can't parse '-archive' date and time");
+ afs_com_err(whoami, 0, "%s", ktime_GetDateUsage());
+ return (-1);
}
toTime += 59;
- }
- else
- toTime = 0;
+ } else
+ toTime = 0;
code = ConnectButc(bc_globalConfig, portOffset, &tconn);
- if (code) return(code);
-
- code = TC_SaveDb(tconn, toTime, &taskId);
if (code)
- {
- com_err(whoami, code, "; Failed to save database");
+ return (code);
+
+ code = TC_SaveDb(tconn, toTime, &taskId);
+ if (code) {
+ afs_com_err(whoami, code, "; Failed to save database");
goto exit;
}
/* create status monitor block */
statusPtr = createStatusNode();
lock_Status();
- statusPtr->taskId = taskId;
- statusPtr->port = portOffset;
+ statusPtr->taskId = taskId;
+ statusPtr->port = portOffset;
statusPtr->jobNumber = bc_jobNumber();
- statusPtr->flags &= ~STARTING; /* clearstatus to examine */
+ statusPtr->flags &= ~STARTING; /* clearstatus to examine */
sprintf(statusPtr->taskName, "SaveDb");
unlock_Status();
-exit:
+ exit:
rx_DestroyConnection(tconn);
- return(code);
+ return (code);
}
-bc_restoreDbCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_restoreDbCmd(struct cmd_syndesc *as, void *arock)
{
struct rx_connection *tconn;
afs_int32 portOffset = 0;
code = bc_UpdateHosts();
if (code) {
- com_err(whoami, code, "; Can't retrieve tape hosts");
- return(code);
+ afs_com_err(whoami, code, "; Can't retrieve tape hosts");
+ return (code);
}
if (as->parms[0].items) {
- portOffset = getPortOffset(as->parms[0].items->data);
- if (portOffset < 0) return(BC_BADARG);
+ portOffset = getPortOffset(as->parms[0].items->data);
+ if (portOffset < 0)
+ return (BC_BADARG);
}
code = ConnectButc(bc_globalConfig, portOffset, &tconn);
- if (code) return(code);
-
- code = TC_RestoreDb(tconn, &taskId);
if (code)
- {
- com_err(whoami, code, "; Failed to restore database");
+ return (code);
+
+ code = TC_RestoreDb(tconn, &taskId);
+ if (code) {
+ afs_com_err(whoami, code, "; Failed to restore database");
goto exit;
}
/* create status monitor block */
statusPtr = createStatusNode();
lock_Status();
- statusPtr->taskId = taskId;
- statusPtr->port = portOffset;
- statusPtr->jobNumber = bc_jobNumber();
- statusPtr->flags &= ~STARTING; /* clearstatus to examine */
+ statusPtr->taskId = taskId;
+ statusPtr->port = portOffset;
+ statusPtr->jobNumber = bc_jobNumber();
+ statusPtr->flags &= ~STARTING; /* clearstatus to examine */
sprintf(statusPtr->taskName, "RestoreDb");
unlock_Status();
-exit:
+ exit:
rx_DestroyConnection(tconn);
- return(code);
+ return (code);
}
/* ----------------------------------
- * supporting routines for database examination
+ * supporting routines for database examination
* ----------------------------------
*/
/* structures and defines for DBLookupByVolume */
-#define DBL_MAX_VOLUMES 20 /* max. for each dump */
+#define DBL_MAX_VOLUMES 20 /* max. for each dump */
/* dumpedVol - saves interesting information so that we can print it out
* later
*/
-struct dumpedVol
-{
+struct dumpedVol {
struct dumpedVol *next;
afs_int32 dumpID;
afs_int32 initialDumpID;
afs_int32 level;
afs_int32 parent;
afs_int32 createTime;
- afs_int32 incTime; /* actually the clone time */
+ afs_int32 incTime; /* actually the clone time */
};
/* -----------------------------------------
* volumeName - volume to lookup
*/
-DBLookupByVolume(volumeName)
- char *volumeName;
+static int
+DBLookupByVolume(char *volumeName)
{
struct budb_dumpEntry dumpEntry;
struct budb_volumeEntry volumeEntry[DBL_MAX_VOLUMES];
afs_int32 numEntries;
afs_int32 tapedumpid;
- afs_int32 last,next;
+ afs_int32 last, next;
struct dumpedVol *dvptr = 0;
struct dumpedVol *tempPtr = 0;
- afs_int32 code=0;
+ afs_int32 code = 0;
int i, pass;
char vname[BU_MAXNAMELEN];
char ds[50];
-
+
for (pass = 0; pass < 2; pass++) {
- /*p*/
- /* On second pass, search for backup volume */
- if (pass == 1) {
- if (!BackupName(volumeName)) {
- strcpy(vname, volumeName);
- strcat(vname, ".backup");
- volumeName = vname;
- }
- else {
- continue;
- }
- }
-
- last = next = 0;
- while ( next != -1 )
- { /*w*/
- code = bcdb_LookupVolume(volumeName, &volumeEntry[0],
- last, &next, DBL_MAX_VOLUMES, &numEntries);
- if (code) break;
-
- /* add the volumes to the list */
- for ( i = 0; i < numEntries; i++ )
- { /*f*/
- struct dumpedVol *insPtr, **prevPtr;
-
- tempPtr = (struct dumpedVol *) malloc(sizeof(struct dumpedVol));
- if (!tempPtr) ERROR(BC_NOMEM);
-
- memset(tempPtr, 0, sizeof(*tempPtr));
- tempPtr->incTime = volumeEntry[i].clone;
- tempPtr->dumpID = volumeEntry[i].dump;
- strncpy(tempPtr->tapeName, volumeEntry[i].tape, BU_MAXTAPELEN);
-
- /* check if we need to null terminate it - just for safety */
- if ( strlen(volumeEntry[i].tape) >= BU_MAXTAPELEN )
- tempPtr->tapeName[BU_MAXTAPELEN-1] = 0;
-
- code = bcdb_FindDumpByID(tempPtr->dumpID, &dumpEntry);
- if (code)
- {
- free(tempPtr);
- ERROR(code);
- }
-
- tempPtr->initialDumpID = dumpEntry.initialDumpID;
- tempPtr->parent = dumpEntry.parent;
- tempPtr->level = dumpEntry.level;
- tempPtr->createTime = dumpEntry.created;
-
- /* add volume to list in reverse chronological order */
- prevPtr = &dvptr;
- insPtr = dvptr;
-
- while ( (insPtr != 0)
- && (insPtr->createTime > tempPtr->createTime)
- )
- {
- prevPtr = &insPtr->next;
- insPtr = insPtr->next;
- }
-
- /* now at the right place - insert the block */
- tempPtr->next = *prevPtr;
- *prevPtr = tempPtr;
- } /*f*/
-
- last = next;
- } /*w*/
- } /*p*/
-
+ /*p */
+ /* On second pass, search for backup volume */
+ if (pass == 1) {
+ if (!BackupName(volumeName)) {
+ strcpy(vname, volumeName);
+ strcat(vname, ".backup");
+ volumeName = vname;
+ } else {
+ continue;
+ }
+ }
+
+ last = next = 0;
+ while (next != -1) { /*w */
+ code =
+ bcdb_LookupVolume(volumeName, &volumeEntry[0], last, &next,
+ DBL_MAX_VOLUMES, &numEntries);
+ if (code)
+ break;
+
+ /* add the volumes to the list */
+ for (i = 0; i < numEntries; i++) { /*f */
+ struct dumpedVol *insPtr, **prevPtr;
+
+ tempPtr =
+ (struct dumpedVol *)malloc(sizeof(struct dumpedVol));
+ if (!tempPtr)
+ ERROR(BC_NOMEM);
+
+ memset(tempPtr, 0, sizeof(*tempPtr));
+ tempPtr->incTime = volumeEntry[i].clone;
+ tempPtr->dumpID = volumeEntry[i].dump;
+ strncpy(tempPtr->tapeName, volumeEntry[i].tape,
+ BU_MAXTAPELEN);
+
+ /* check if we need to null terminate it - just for safety */
+ if (strlen(volumeEntry[i].tape) >= BU_MAXTAPELEN)
+ tempPtr->tapeName[BU_MAXTAPELEN - 1] = 0;
+
+ code = bcdb_FindDumpByID(tempPtr->dumpID, &dumpEntry);
+ if (code) {
+ free(tempPtr);
+ ERROR(code);
+ }
+
+ tempPtr->initialDumpID = dumpEntry.initialDumpID;
+ tempPtr->parent = dumpEntry.parent;
+ tempPtr->level = dumpEntry.level;
+ tempPtr->createTime = dumpEntry.created;
+
+ /* add volume to list in reverse chronological order */
+ prevPtr = &dvptr;
+ insPtr = dvptr;
+
+ while ((insPtr != 0)
+ && (insPtr->createTime > tempPtr->createTime)
+ ) {
+ prevPtr = &insPtr->next;
+ insPtr = insPtr->next;
+ }
+
+ /* now at the right place - insert the block */
+ tempPtr->next = *prevPtr;
+ *prevPtr = tempPtr;
+ } /*f */
+
+ last = next;
+ } /*w */
+ } /*p */
+
if (dvptr) {
- printf("DumpID lvl parentID creation date clone date tape name\n");
- for (tempPtr = dvptr; tempPtr; tempPtr = tempPtr->next) {
- /* For the user, the tape name is its name and initial dump id */
- tapedumpid = (tempPtr->initialDumpID ? tempPtr->initialDumpID : tempPtr->dumpID);
-
- /* beware the static items in compactDateString */
- compactDateString(&tempPtr->createTime, ds, 50);
- printf("%-9d %-2d %-9d %16s",
- tempPtr->dumpID, tempPtr->level, tempPtr->parent, ds);
- compactDateString(&tempPtr->incTime, ds, 50);
- printf(" %16s %s (%u)\n", ds, tempPtr->tapeName, tapedumpid);
- }
- code = 0;
- }
-
-error_exit:
+ printf
+ ("DumpID lvl parentID creation date clone date tape name\n");
+ for (tempPtr = dvptr; tempPtr; tempPtr = tempPtr->next) {
+ /* For the user, the tape name is its name and initial dump id */
+ tapedumpid =
+ (tempPtr->initialDumpID ? tempPtr->initialDumpID : tempPtr->
+ dumpID);
+
+ /* beware the static items in compactDateString */
+ compactDateString(&tempPtr->createTime, ds, 50);
+ printf("%-9d %-2d %-9d %16s", tempPtr->dumpID, tempPtr->level,
+ tempPtr->parent, ds);
+ compactDateString(&tempPtr->incTime, ds, 50);
+ printf(" %16s %s (%u)\n", ds, tempPtr->tapeName, tapedumpid);
+ }
+ code = 0;
+ }
+
+ error_exit:
for (tempPtr = dvptr; tempPtr; tempPtr = dvptr) {
dvptr = dvptr->next;
free(tempPtr);
}
if (code)
- com_err(whoami, code, "");
- return(code);
+ afs_com_err(whoami, code, NULL);
+ return (code);
}
/* structures for dumpInfo */
-struct volumeLink
-{
+struct volumeLink {
struct volumeLink *nextVolume;
struct budb_volumeEntry volumeEntry;
};
-struct tapeLink
-{
+struct tapeLink {
struct tapeLink *nextTape;
struct budb_tapeEntry tapeEntry;
struct volumeLink *firstVolume;
*/
afs_int32
-dumpInfo(dumpid, detailFlag)
- afs_int32 dumpid;
- afs_int32 detailFlag;
+dumpInfo(afs_int32 dumpid, afs_int32 detailFlag)
{
struct budb_dumpEntry dumpEntry;
struct tapeLink *head = 0;
budb_volumeList vl;
afs_int32 last, next, dbTime;
afs_int32 tapedumpid;
- afs_int32 numTapes;
int tapeNumber;
int i;
lastTapeLinkPtr = 0;
volumeLinkPtr = 0;
lastVolumeLinkPtr = 0;
-
+
/* first get information about the dump */
code = bcdb_FindDumpByID(dumpid, &dumpEntry);
- if (code) ERROR(code);
+ if (code)
+ ERROR(code);
/* For the user, the tape name is its name and initial dump id */
tapedumpid = (dumpEntry.initialDumpID ? dumpEntry.initialDumpID : dumpid);
/* Is this a database dump id or not */
- if ( strcmp(dumpEntry.name,DUMP_TAPE_NAME) == 0 )
- dbDump = 1;
+ if (strcmp(dumpEntry.name, DUMP_TAPE_NAME) == 0)
+ dbDump = 1;
else
- dbDump = 0;
+ dbDump = 0;
/* print out the information about the dump */
if (detailFlag) {
printf("----\n");
printDumpEntry(&dumpEntry);
} else {
- if ( dbDump )
- printf("Dump: id %u, created: %s\n",
- dumpEntry.id, ctime(&dumpEntry.created));
- else
+ time_t t = dumpEntry.created;
+ if (dbDump)
+ printf("Dump: id %u, created: %s\n", dumpEntry.id,
+ ctime(&t));
+ else
printf("Dump: id %u, level %d, volumes %d, created: %s\n",
dumpEntry.id, dumpEntry.level, dumpEntry.nVolumes,
- ctime(&dumpEntry.created));
+ ctime(&t));
}
- if ( !detailFlag && (strlen(dumpEntry.tapes.tapeServer) > 0) &&
- (dumpEntry.flags & (BUDB_DUMP_ADSM | BUDB_DUMP_BUTA)) ) {
- printf("Backup Service: TSM: Server: %s\n",
- dumpEntry.tapes.tapeServer);
+ if (!detailFlag && (strlen(dumpEntry.tapes.tapeServer) > 0)
+ && (dumpEntry.flags & (BUDB_DUMP_ADSM | BUDB_DUMP_BUTA))) {
+ printf("Backup Service: TSM: Server: %s\n",
+ dumpEntry.tapes.tapeServer);
}
/* now get the list of tapes */
- for (tapeNumber=dumpEntry.tapes.b; tapeNumber<=dumpEntry.tapes.maxTapes; tapeNumber++)
- { /*f*/
- tapeLinkPtr = (struct tapeLink *) malloc(sizeof(struct tapeLink));
- if (!tapeLinkPtr)
- {
- com_err(whoami,BC_NOMEM,"");
+ for (tapeNumber = dumpEntry.tapes.b; tapeNumber <= dumpEntry.tapes.maxTapes; tapeNumber++) { /*f */
+ tapeLinkPtr = (struct tapeLink *)malloc(sizeof(struct tapeLink));
+ if (!tapeLinkPtr) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
ERROR(BC_NOMEM);
}
memset(tapeLinkPtr, 0, sizeof(*tapeLinkPtr));
code = bcdb_FindTapeSeq(dumpid, tapeNumber, &tapeLinkPtr->tapeEntry);
- if (code)
- {
+ if (code) {
code = 0;
free(tapeLinkPtr);
continue;
}
/* add this tape to previous chain */
- if (lastTapeLinkPtr)
- {
+ if (lastTapeLinkPtr) {
lastTapeLinkPtr->nextTape = tapeLinkPtr;
lastTapeLinkPtr = tapeLinkPtr;
}
- if (head == 0)
- {
+ if (head == 0) {
head = tapeLinkPtr;
lastTapeLinkPtr = head;
}
next = 0;
- while (next != -1)
- { /*wn*/
+ while (next != -1) { /*wn */
vl.budb_volumeList_len = 0;
vl.budb_volumeList_val = 0;
last = next;
/* now get all the volumes in this dump. */
- code = ubik_Call_SingleServer(BUDB_GetVolumes, udbHandle.uh_client,
- UF_SINGLESERVER,
- BUDB_MAJORVERSION,
- BUDB_OP_DUMPID | BUDB_OP_TAPENAME,
- tapeLinkPtr->tapeEntry.name, /* tape name */
- dumpid, /* dumpid (not initial dumpid) */
- 0, /* end */
- last, /* last */
- &next, /* nextindex */
- &dbTime, /* update time */
+ code = ubik_Call_SingleServer(BUDB_GetVolumes, udbHandle.uh_client, UF_SINGLESERVER, BUDB_MAJORVERSION, BUDB_OP_DUMPID | BUDB_OP_TAPENAME, tapeLinkPtr->tapeEntry.name, /* tape name */
+ dumpid, /* dumpid (not initial dumpid) */
+ 0, /* end */
+ last, /* last */
+ &next, /* nextindex */
+ &dbTime, /* update time */
&vl);
- if (code)
- {
- if ( code == BUDB_ENDOFLIST ) /* 0 volumes on tape */
- {
+ if (code) {
+ if (code == BUDB_ENDOFLIST) { /* 0 volumes on tape */
code = 0;
break;
}
ERROR(code);
}
- for (i=0; i<vl.budb_volumeList_len; i++)
- {
+ for (i = 0; i < vl.budb_volumeList_len; i++) {
link = &tapeLinkPtr->firstVolume;
- volumeLinkPtr = (struct volumeLink *) malloc(sizeof(struct volumeLink));
- if (!volumeLinkPtr)
- {
- com_err(whoami,BC_NOMEM,"");
+ volumeLinkPtr =
+ (struct volumeLink *)malloc(sizeof(struct volumeLink));
+ if (!volumeLinkPtr) {
+ afs_com_err(whoami, BC_NOMEM, NULL);
ERROR(BC_NOMEM);
}
memset(volumeLinkPtr, 0, sizeof(*volumeLinkPtr));
- memcpy(&volumeLinkPtr->volumeEntry, &vl.budb_volumeList_val[i], sizeof(struct budb_volumeEntry));
+ memcpy(&volumeLinkPtr->volumeEntry,
+ &vl.budb_volumeList_val[i],
+ sizeof(struct budb_volumeEntry));
/* now insert it onto the right place */
- while ( (*link != 0) &&
- (volumeLinkPtr->volumeEntry.position > (*link)->volumeEntry.position) )
- {
+ while ((*link != 0)
+ && (volumeLinkPtr->volumeEntry.position >
+ (*link)->volumeEntry.position)) {
link = &((*link)->nextVolume);
}
*link = volumeLinkPtr;
}
- if (vl.budb_volumeList_val) free(vl.budb_volumeList_val);
- } /*wn*/
- } /*f*/
+ if (vl.budb_volumeList_val)
+ free(vl.budb_volumeList_val);
+ } /*wn */
+ } /*f */
- for (tapeLinkPtr=head; tapeLinkPtr; tapeLinkPtr=tapeLinkPtr->nextTape)
- {
+ for (tapeLinkPtr = head; tapeLinkPtr; tapeLinkPtr = tapeLinkPtr->nextTape) {
if (detailFlag) {
printf("\nTape\n");
printf("----\n");
printTapeEntry(&tapeLinkPtr->tapeEntry);
} else {
- printf("Tape: name %s (%u)\n", tapeLinkPtr->tapeEntry.name, tapedumpid);
+ printf("Tape: name %s (%u)\n", tapeLinkPtr->tapeEntry.name,
+ tapedumpid);
printf("nVolumes %d, ", tapeLinkPtr->tapeEntry.nVolumes);
compactDateString(&tapeLinkPtr->tapeEntry.written, ds, 50);
printf("created %16s", ds);
- if ( tapeLinkPtr->tapeEntry.expires != 0 ) {
- compactDateString(&tapeLinkPtr->tapeEntry.expires, ds, 50);
- printf(", expires %16s", ds);
+ if (tapeLinkPtr->tapeEntry.expires != 0) {
+ compactDateString(&tapeLinkPtr->tapeEntry.expires, ds, 50);
+ printf(", expires %16s", ds);
}
printf("\n\n");
}
/* print out all the volumes */
/* print header for volume listing - db dumps have no volumes */
- if ( (detailFlag == 0) && !dbDump )
- printf("%4s %16s %9s %-s\n", "Pos", "Clone time", "Nbytes", "Volume");
-
- for (volumeLinkPtr=tapeLinkPtr->firstVolume; volumeLinkPtr;
- volumeLinkPtr=volumeLinkPtr->nextVolume)
- {
- if (detailFlag)
- {
+ if ((detailFlag == 0) && !dbDump)
+ printf("%4s %16s %9s %-s\n", "Pos", "Clone time", "Nbytes",
+ "Volume");
+
+ for (volumeLinkPtr = tapeLinkPtr->firstVolume; volumeLinkPtr;
+ volumeLinkPtr = volumeLinkPtr->nextVolume) {
+ if (detailFlag) {
printf("\nVolume\n");
printf("------\n");
printVolumeEntry(&volumeLinkPtr->volumeEntry);
- }
- else
- {
- compactDateString(&volumeLinkPtr->volumeEntry.clone, ds, 50),
- printf("%4d %s %10u %16s\n",
- volumeLinkPtr->volumeEntry.position,
- ds,
- volumeLinkPtr->volumeEntry.nBytes,
- volumeLinkPtr->volumeEntry.name);
+ } else {
+ compactDateString(&volumeLinkPtr->volumeEntry.clone, ds, 50),
+ printf("%4d %s %10u %16s\n",
+ volumeLinkPtr->volumeEntry.position, ds,
+ volumeLinkPtr->volumeEntry.nBytes,
+ volumeLinkPtr->volumeEntry.name);
}
}
}
-error_exit:
- if (code) com_err("dumpInfo", code, "; Can't get dump information");
+ error_exit:
+ if (code)
+ afs_com_err("dumpInfo", code, "; Can't get dump information");
/* free all allocated structures */
tapeLinkPtr = head;
- while ( tapeLinkPtr )
- {
+ while (tapeLinkPtr) {
volumeLinkPtr = tapeLinkPtr->firstVolume;
- while ( volumeLinkPtr )
- {
+ while (volumeLinkPtr) {
lastVolumeLinkPtr = volumeLinkPtr;
volumeLinkPtr = volumeLinkPtr->nextVolume;
free(lastVolumeLinkPtr);
}
-
+
lastTapeLinkPtr = tapeLinkPtr;
tapeLinkPtr = tapeLinkPtr->nextTape;
free(lastTapeLinkPtr);
}
- return(code);
+ return (code);
}
-compareDump(ptr1, ptr2)
- struct budb_dumpEntry *ptr1, *ptr2;
+int
+compareDump(struct budb_dumpEntry *ptr1, struct budb_dumpEntry *ptr2)
{
- if ( ptr1->created < ptr2->created )
- return(-1);
- else
- if ( ptr1->created > ptr2->created )
- return(1);
- return(0);
+ if (ptr1->created < ptr2->created)
+ return (-1);
+ else if (ptr1->created > ptr2->created)
+ return (1);
+ return (0);
}
-afs_int32 printRecentDumps(ndumps)
- int ndumps;
+afs_int32
+printRecentDumps(int ndumps)
{
- afs_int32 code = 0;
- afs_int32 nextindex, index = 0;
- afs_int32 dbTime;
- afs_int32 tapedumpid;
+ afs_int32 code = 0;
+ afs_int32 nextindex, index = 0;
+ afs_int32 dbTime;
budb_dumpList dl;
struct budb_dumpEntry *dumpPtr;
int i;
char ds[50];
extern struct udbHandleS udbHandle;
- extern compareDump();
-
- do { /* while (nextindex != -1) */
- /* initialize the dump list */
- dl.budb_dumpList_len = 0;
- dl.budb_dumpList_val = 0;
-
- /* outline algorithm */
- code = ubik_Call (BUDB_GetDumps, udbHandle.uh_client, 0,
- BUDB_MAJORVERSION,
- BUDB_OP_NPREVIOUS,
- "", /* no name */
- 0, /* start */
- ndumps, /* end */
- index, /* index */
- &nextindex,
- &dbTime,
- &dl);
- if (code) {
- if (code == BUDB_ENDOFLIST) return 0;
- com_err("dumpInfo", code, "; Can't get dump information");
- return(code);
- }
-
- /* No need to sort, it's already sorted */
-
- if (dl.budb_dumpList_len && (index == 0))
- printf("%10s %10s %2s %-16s %2s %5s dump name\n",
- "dumpid", "parentid", "lv", "created", "nt", "nvols");
-
- dumpPtr = dl.budb_dumpList_val;
- for ( i = 1; i <= dl.budb_dumpList_len; i++ ) {
- compactDateString(&dumpPtr->created, ds, 50),
- printf("%10u %10u %-2d %16s %2d %5d %s",
- dumpPtr->id,
- dumpPtr->parent,
- dumpPtr->level,
- ds,
- dumpPtr->tapes.maxTapes - dumpPtr->tapes.b + 1,
- dumpPtr->nVolumes,
- dumpPtr->name,
- tapedumpid);
- if (dumpPtr->initialDumpID) /* an appended dump */
- printf(" (%u)", dumpPtr->initialDumpID);
- else if (dumpPtr->appendedDumpID) /* has appended dumps */
- printf(" (%u)", dumpPtr->id);
- printf("\n");
-
- dumpPtr++;
- }
- if (dl.budb_dumpList_val) free(dl.budb_dumpList_val);
- index = nextindex;
- } while (nextindex != -1);
+ do { /* while (nextindex != -1) */
+ /* initialize the dump list */
+ dl.budb_dumpList_len = 0;
+ dl.budb_dumpList_val = 0;
+
+ /* outline algorithm */
+ code = ubik_BUDB_GetDumps(udbHandle.uh_client, 0, BUDB_MAJORVERSION, BUDB_OP_NPREVIOUS, "", /* no name */
+ 0, /* start */
+ ndumps, /* end */
+ index, /* index */
+ &nextindex, &dbTime, &dl);
+ if (code) {
+ if (code == BUDB_ENDOFLIST)
+ return 0;
+ afs_com_err("dumpInfo", code, "; Can't get dump information");
+ return (code);
+ }
+
+ /* No need to sort, it's already sorted */
+
+ if (dl.budb_dumpList_len && (index == 0))
+ printf("%10s %10s %2s %-16s %2s %5s dump name\n", "dumpid",
+ "parentid", "lv", "created", "nt", "nvols");
+
+ dumpPtr = dl.budb_dumpList_val;
+ for (i = 1; i <= dl.budb_dumpList_len; i++) {
+ compactDateString(&dumpPtr->created, ds, 50),
+ printf("%10u %10u %-2d %16s %2d %5d %s", dumpPtr->id,
+ dumpPtr->parent, dumpPtr->level, ds,
+ dumpPtr->tapes.maxTapes - dumpPtr->tapes.b + 1,
+ dumpPtr->nVolumes, dumpPtr->name);
+ if (dumpPtr->initialDumpID) /* an appended dump */
+ printf(" (%u)", dumpPtr->initialDumpID);
+ else if (dumpPtr->appendedDumpID) /* has appended dumps */
+ printf(" (%u)", dumpPtr->id);
+ printf("\n");
+
+ dumpPtr++;
+ }
- return(code);
+ if (dl.budb_dumpList_val)
+ free(dl.budb_dumpList_val);
+ index = nextindex;
+ } while (nextindex != -1);
+
+ return (code);
}
-/* bc_dumpInfoCmd
+/* bc_dumpInfoCmd
* list the dumps and contens of the dumps.
* params:
* as - name of tape
* arock -
*/
-bc_dumpInfoCmd(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+bc_dumpInfoCmd(struct cmd_syndesc *as, void *arock)
{
afs_int32 dumpid;
afs_int32 detailFlag;
afs_int32 ndumps;
afs_int32 code = 0;
- afs_int32 dumpInfo();
-
- if( as->parms[0].items )
- {
- if(as->parms[1].items)
- {
- com_err(whoami, 0, "These options are exclusive - select only one");
- return(BC_BADARG);
+ if (as->parms[0].items) {
+ if (as->parms[1].items) {
+ afs_com_err(whoami, 0,
+ "These options are exclusive - select only one");
+ return (BC_BADARG);
}
ndumps = atoi(as->parms[0].items->data);
- if (ndumps <= 0)
- {
- com_err(whoami, 0, "Must provide a positive number");
+ if (ndumps <= 0) {
+ afs_com_err(whoami, 0, "Must provide a positive number");
return -1;
}
code = printRecentDumps(ndumps);
- }
- else if (as->parms[1].items)
- {
- detailFlag = (as->parms[2].items ? 1 : 0); /* 1 = detailed listing */
- dumpid = atoi(as->parms[1].items->data);
+ } else if (as->parms[1].items) {
+ detailFlag = (as->parms[2].items ? 1 : 0); /* 1 = detailed listing */
+ dumpid = atoi(as->parms[1].items->data);
code = dumpInfo(dumpid, detailFlag);
- }
- else
- {
- code = printRecentDumps(10);
+ } else {
+ code = printRecentDumps(10);
}
- return(code);
+ return (code);
}
git://git.openafs.org / openafs.git / blobdiff