/*
* 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 <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <afs/procmgmt.h> /* signal(), kill(), wait(), etc. */
#include <setjmp.h>
+#include "volser_internal.h"
#include "volser_prototypes.h"
#include "vsutils_prototypes.h"
#include "lockprocs_prototypes.h"
/* Protos for static routines */
+#if 0
static afs_int32 CheckAndDeleteVolume(struct rx_connection *aconn,
afs_int32 apart, afs_uint32 okvol,
afs_uint32 delvol);
+#endif
static int DelVol(struct rx_connection *conn, afs_uint32 vid, afs_int32 part,
afs_int32 flags);
static int GetTrans(struct nvldbentry *vldbEntryPtr, afs_int32 index,
struct rx_connection **connPtr, afs_int32 * transPtr,
- afs_int32 * crtimePtr, afs_int32 * uptimePtr);
+ afs_uint32 * crtimePtr, afs_uint32 * uptimePtr);
static int SimulateForwardMultiple(struct rx_connection *fromconn,
afs_int32 fromtid, afs_int32 fromdate,
manyDests * tr, afs_int32 flags,
void *cookie, manyResults * results);
-static afs_int32 CheckVolume(volintInfo * volumeinfo, afs_int32 aserver,
+static afs_int32 CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver,
afs_int32 apart, afs_int32 * modentry,
- afs_uint32 * maxvolid);
+ afs_uint32 * maxvolid, struct nvldbentry *aentry);
/*map the partition <partId> into partition name <partName>*/
int
PrintError(char *msg, afs_int32 errcode)
{
- fprintf(STDERR, msg);
+ fprintf(STDERR, "%s", msg);
/*replace by a big switch statement */
switch (errcode) {
case 0:
break;
default:
{
-
- afs_int32 offset;
-
initialize_KA_error_table();
initialize_RXK_error_table();
initialize_KTC_error_table();
initialize_CMD_error_table();
initialize_VL_error_table();
- offset = errcode & ((1 << ERRCODE_RANGE) - 1);
fprintf(STDERR, "%s: %s\n", afs_error_table_name(errcode),
afs_error_message(errcode));
break;
static int uvindex = -1;
/* called by VLDBClient_Init to set the security module to be used in the RPC */
int
-UV_SetSecurity(register struct rx_securityClass *as, afs_int32 aindex)
+UV_SetSecurity(struct rx_securityClass *as, afs_int32 aindex)
{
uvindex = aindex;
uvclass = as;
/* bind to volser on <port> <aserver> */
/* takes server address in network order, port in host order. dumb */
struct rx_connection *
-UV_Bind(afs_int32 aserver, afs_int32 port)
+UV_Bind(afs_uint32 aserver, afs_int32 port)
{
- register struct rx_connection *tc;
+ struct rx_connection *tc;
tc = rx_NewConnection(aserver, htons(port), VOLSERVICE_ID, uvclass,
uvindex);
return tc;
}
-static int
+static int
AFSVolCreateVolume_retry(struct rx_connection *z_conn,
afs_int32 partition, char *name, afs_int32 type,
- afs_int32 parent, afs_int32 *volid, afs_int32 *trans)
+ afs_int32 parent, afs_uint32 *volid, afs_int32 *trans)
{
afs_int32 code;
int retries = 3;
return code;
}
-static int
+static int
AFSVolTransCreate_retry(struct rx_connection *z_conn,
- afs_int32 volume, afs_int32 partition,
- afs_int32 flags, afs_int32 * trans)
+ afs_int32 volume, afs_int32 partition,
+ afs_int32 flags, afs_int32 * trans)
{
afs_int32 code;
int retries = 3;
return code;
}
+#if 0
/* if <okvol> is allright(indicated by beibg able to
* start a transaction, delete the <delvol> */
static afs_int32
}
}
+#endif
+
/* called by EmuerateEntry, show vldb entry in a reasonable format */
void
SubEnumerateEntry(struct nvldbentry *entry)
for (i = 0; i < entry->nServers; i++) {
MapPartIdIntoName(entry->serverPartition[i], pname);
fprintf(STDOUT, " server %s partition %s ",
- noresolve ? afs_inet_ntoa_r(entry->serverNumber[i], hoststr) :
+ noresolve ? afs_inet_ntoa_r(entry->serverNumber[i], hoststr) :
hostutil_GetNameByINet(entry->serverNumber[i]), pname);
if (entry->serverFlags[i] & ITSRWVOL)
fprintf(STDOUT, "RW Site ");
/* forcibly remove a volume. Very dangerous call */
int
-UV_NukeVolume(afs_int32 server, afs_int32 partid, afs_uint32 volid)
+UV_NukeVolume(afs_uint32 server, afs_int32 partid, afs_uint32 volid)
{
- register struct rx_connection *tconn;
- register afs_int32 code;
+ struct rx_connection *tconn;
+ afs_int32 code;
tconn = UV_Bind(server, AFSCONF_VOLUMEPORT);
if (tconn) {
/* like df. Return usage of <pname> on <server> in <partition> */
int
-UV_PartitionInfo64(afs_int32 server, char *pname,
+UV_PartitionInfo64(afs_uint32 server, char *pname,
struct diskPartition64 *partition)
{
- register struct rx_connection *aconn;
+ struct rx_connection *aconn;
afs_int32 code = 0;
aconn = (struct rx_connection *)0;
aconn = UV_Bind(server, AFSCONF_VOLUMEPORT);
code = AFSVolPartitionInfo64(aconn, pname, partition);
if (code == RXGEN_OPCODE) {
- struct diskPartition *dpp =
+ struct diskPartition *dpp =
(struct diskPartition *)malloc(sizeof(struct diskPartition));
code = AFSVolPartitionInfo(aconn, pname, dpp);
if (!code) {
partition->minFree = dpp->minFree;
}
free(dpp);
- }
+ }
if (code) {
fprintf(STDERR, "Could not get information on partition %s\n", pname);
PrintError("", code);
return code;
}
-/* old interface to create volume */
+/* old interface to create volumes */
int
-UV_CreateVolume(afs_int32 aserver, afs_int32 apart, char *aname,
+UV_CreateVolume(afs_uint32 aserver, afs_int32 apart, char *aname,
afs_uint32 * anewid)
{
afs_int32 code;
+ *anewid = 0;
code = UV_CreateVolume2(aserver, apart, aname, 5000, 0, 0, 0, 0, anewid);
return code;
}
-/* create a volume, given a server, partition number, volume name --> sends
-* back new vol id in <anewid>*/
+/* less old interface to create volumes */
int
-UV_CreateVolume2(afs_int32 aserver, afs_int32 apart, char *aname,
+UV_CreateVolume2(afs_uint32 aserver, afs_int32 apart, char *aname,
afs_int32 aquota, afs_int32 aspare1, afs_int32 aspare2,
afs_int32 aspare3, afs_int32 aspare4, afs_uint32 * anewid)
{
- register struct rx_connection *aconn;
+ afs_uint32 roid = 0, bkid = 0;
+ return UV_CreateVolume3(aserver, apart, aname, aquota, aspare1, aspare2,
+ aspare3, aspare4, anewid, &roid, &bkid);
+}
+
+/**
+ * Create a volume on the given server and partition
+ *
+ * @param aserver server to create volume on
+ * @param spart partition to create volume on
+ * @param aname name of new volume
+ * @param aquota quota for new volume
+ * @param anewid contains the desired volume id for the new volume. If
+ * *anewid == 0, a new id will be chosen, and will be placed
+ * in *anewid when UV_CreateVolume3 returns.
+ * @param aroid contains the desired RO volume id. If NULL, the RO id entry
+ * will be unset. If *aroid == 0, an id will be chosen, and
+ * will be placed in *anewid when UV_CreateVolume3 returns.
+ * @param abkid same as aroid, except for the BK volume id instead of the
+ * RO volume id.
+ * @return 0 on success, error code otherwise.
+ */
+int
+UV_CreateVolume3(afs_uint32 aserver, afs_int32 apart, char *aname,
+ afs_int32 aquota, afs_int32 aspare1, afs_int32 aspare2,
+ afs_int32 aspare3, afs_int32 aspare4, afs_uint32 * anewid,
+ afs_uint32 * aroid, afs_uint32 * abkid)
+{
+ struct rx_connection *aconn;
afs_int32 tid;
- register afs_int32 code;
+ afs_int32 code;
afs_int32 error;
afs_int32 rcode, vcode;
+ afs_int32 lastid;
struct nvldbentry entry, storeEntry; /*the new vldb entry */
struct volintInfo tstatus;
tstatus.maxquota = aquota;
aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT);
- /* next the next 3 available ids from the VLDB */
- vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 3, anewid);
- EGOTO1(cfail, vcode, "Could not get an Id for volume %s\n", aname);
+
+ if (aroid && *aroid) {
+ VPRINT1("Using RO volume ID %d.\n", *aroid);
+ }
+ if (abkid && *abkid) {
+ VPRINT1("Using BK volume ID %d.\n", *abkid);
+ }
+
+ if (*anewid) {
+ vcode = VLDB_GetEntryByID(*anewid, -1, &entry);
+ if (!vcode) {
+ fprintf(STDERR, "Volume ID %d already exists\n", *anewid);
+ return VVOLEXISTS;
+ }
+ VPRINT1("Using volume ID %d.\n", *anewid);
+ } else {
+ vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, anewid);
+ EGOTO1(cfail, vcode, "Could not get an Id for volume %s\n", aname);
+
+ if (aroid && *aroid == 0) {
+ vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, aroid);
+ EGOTO1(cfail, vcode, "Could not get an RO Id for volume %s\n", aname);
+ }
+
+ if (abkid && *abkid == 0) {
+ vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, abkid);
+ EGOTO1(cfail, vcode, "Could not get a BK Id for volume %s\n", aname);
+ }
+ }
+
+ /* rw,ro, bk id are related in the default case */
+ /* If caller specified RW id, but not RO/BK ids, have them be RW+1 and RW+2 */
+ lastid = *anewid;
+ if (aroid && *aroid == 0) {
+ *aroid = ++lastid;
+ }
+ if (abkid && *abkid == 0) {
+ *abkid = ++lastid;
+ }
+
code =
- AFSVolCreateVolume_retry(aconn, apart, aname, volser_RW, 0, anewid, &tid);
+ AFSVolCreateVolume_retry(aconn, apart, aname, volser_RW, 0, anewid, &tid);
EGOTO2(cfail, code, "Failed to create the volume %s %u \n", aname,
*anewid);
EPRINT(code, "Could not change quota, continuing...\n");
code = AFSVolSetFlags(aconn, tid, 0); /* bring it online (mark it InService */
- EGOTO2(cfail, vcode, "Could not bring the volume %s %u online \n", aname,
+ EGOTO2(cfail, code, "Could not bring the volume %s %u online \n", aname,
*anewid);
VPRINT2("Volume %s %u created and brought online\n", aname, *anewid);
/* set up the vldb entry for this volume */
strncpy(entry.name, aname, VOLSER_OLDMAXVOLNAME);
entry.nServers = 1;
- entry.serverNumber[0] = aserver; /* this should have another
+ entry.serverNumber[0] = aserver; /* this should have another
* level of indirection later */
- entry.serverPartition[0] = apart; /* this should also have
+ entry.serverPartition[0] = apart; /* this should also have
* another indirection level */
entry.flags = RW_EXISTS; /* this records that rw volume exists */
entry.serverFlags[0] = ITSRWVOL; /*this rep site has rw vol */
entry.volumeId[RWVOL] = *anewid;
- entry.volumeId[ROVOL] = *anewid + 1; /* rw,ro, bk id are related in the default case */
- entry.volumeId[BACKVOL] = *anewid + 2;
+ entry.volumeId[ROVOL] = aroid ? *aroid : 0;
+ entry.volumeId[BACKVOL] = abkid ? *abkid : 0;
entry.cloneId = 0;
/*map into right byte order, before passing to xdr, the stuff has to be in host
* byte order. Xdr converts it into network order */
/* create a volume, given a server, partition number, volume name --> sends
* back new vol id in <anewid>*/
int
-UV_AddVLDBEntry(afs_int32 aserver, afs_int32 apart, char *aname,
+UV_AddVLDBEntry(afs_uint32 aserver, afs_int32 apart, char *aname,
afs_uint32 aid)
{
- register struct rx_connection *aconn;
+ struct rx_connection *aconn;
afs_int32 error;
afs_int32 vcode;
struct nvldbentry entry, storeEntry; /*the new vldb entry */
/* set up the vldb entry for this volume */
strncpy(entry.name, aname, VOLSER_OLDMAXVOLNAME);
entry.nServers = 1;
- entry.serverNumber[0] = aserver; /* this should have another
+ entry.serverNumber[0] = aserver; /* this should have another
* level of indirection later */
- entry.serverPartition[0] = apart; /* this should also have
+ entry.serverPartition[0] = apart; /* this should also have
* another indirection level */
entry.flags = RW_EXISTS; /* this records that rw volume exists */
entry.serverFlags[0] = ITSRWVOL; /*this rep site has rw vol */
}
/* Delete the volume <volid>on <aserver> <apart>
- * the physical entry gets removed from the vldb only if the ref count
+ * the physical entry gets removed from the vldb only if the ref count
* becomes zero
*/
int
-UV_DeleteVolume(afs_int32 aserver, afs_int32 apart, afs_uint32 avolid)
+UV_DeleteVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid)
{
struct rx_connection *aconn = (struct rx_connection *)0;
afs_int32 ttid = 0;
else if (avolid == entry.volumeId[ROVOL]) {
/* Its a read-only volume, modify the VLDB entry. Check that the
* readonly volume is on the server/partition we asked to delete.
- * If flags does not have RO_EIXSTS set, then this may mean the RO
+ * If flags does not have RO_EIXSTS set, then this may mean the RO
* hasn't been released (and could exist in VLDB).
*/
if (!Lp_ROMatch(aserver, apart, &entry)) {
if (islocked) {
code =
ubik_VL_ReleaseLock(cstruct, 0, avolid, -1,
- (LOCKREL_OPCODE | LOCKREL_AFSID |
+ (LOCKREL_OPCODE | LOCKREL_AFSID |
LOCKREL_TIMESTAMP));
if (code) {
EPRINT1(code,
jmp_buf env;
int interrupt = 0;
-void
-sigint_handler(int x)
+static void *
+do_interrupt(void * unused)
{
- if (interrupt)
+ if (interrupt) {
+#if !defined(AFS_PTHREAD_ENV) && !defined(AFS_NT40_ENV)
+ /* Avoid UNIX LWP from getting confused that our stack has suddenly
+ * changed. This will avoid some sanity checks, but until a better way
+ * is found, the only alternative is always crashing and burning on at
+ * least the stack-overflow check. */
+ lwp_cpptr->stack = NULL;
+#endif
longjmp(env, 0);
+ }
fprintf(STDOUT, "\nSIGINT handler: vos move operation in progress\n");
fprintf(STDOUT,
fflush(STDOUT);
interrupt = 1;
- (void)signal(SIGINT, sigint_handler);
+ return NULL;
+}
- return;
+static void
+sigint_handler(int x)
+{
+#ifdef AFS_PTHREAD_ENV
+ do_interrupt(NULL);
+#else
+ IOMGR_SoftSig(do_interrupt, 0);
+#endif
+ (void)signal(SIGINT, sigint_handler);
}
/* Move volume <afromvol> on <afromserver> <afrompart> to <atoserver>
* <atopart>. The operation is almost idempotent. The following
* flags are recognized:
- *
+ *
* RV_NOCLONE - don't use a copy clone
*/
int
-UV_MoveVolume2(afs_uint32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
- afs_int32 atoserver, afs_int32 atopart, int flags)
+UV_MoveVolume2(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
+ afs_uint32 atoserver, afs_int32 atopart, int flags)
{
- struct rx_connection *toconn, *fromconn;
- afs_int32 fromtid, totid, clonetid;
+ /* declare stuff 'volatile' that may be used from setjmp/longjmp and may
+ * be changing during the move */
+ struct rx_connection * volatile toconn;
+ struct rx_connection * volatile fromconn;
+ afs_int32 volatile fromtid;
+ afs_int32 volatile totid;
+ afs_int32 volatile clonetid;
+ afs_uint32 volatile newVol;
+ afs_uint32 volatile volid;
+ afs_uint32 volatile backupId;
+ int volatile islocked;
+ int volatile pntg;
+
char vname[64];
char *volName = 0;
char tmpName[VOLSER_MAXVOLNAME + 1];
afs_int32 rcode;
afs_int32 fromDate;
+ afs_int32 tmp;
+ afs_uint32 tmpVol;
struct restoreCookie cookie;
- register afs_int32 vcode, code;
- afs_uint32 newVol, volid, backupId;
+ afs_int32 vcode, code;
struct volser_status tstatus;
struct destServer destination;
struct nvldbentry entry, storeEntry;
- int i, islocked, pntg;
+ int i;
afs_int32 error;
char in, lf; /* for test code */
int same;
fromtid = 0;
pntg = 1;
+ tmp = fromtid;
code =
AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITOffline,
- &fromtid);
+ &tmp);
+ fromtid = tmp;
if (!code) { /* volume exists - delete it */
VPRINT1("Setting flags on leftover source volume %u ...",
fromtid = 0;
code =
AFSVolTransCreate_retry(fromconn, backupId, afrompart, ITOffline,
- &fromtid);
+ &tmp);
+ fromtid = tmp;
if (!code) { /* backup volume exists - delete it */
VPRINT1("Setting flags on leftover backup volume %u ...",
}
/* From-info matches the vldb info about volid,
- * its ok start the move operation, the backup volume
- * on the old site is deleted in the process
+ * its ok start the move operation, the backup volume
+ * on the old site is deleted in the process
*/
if (afrompart == atopart) {
same = VLDB_IsSameAddrs(afromserver, atoserver, &error);
* ***/
VPRINT1("Starting transaction on source volume %u ...", afromvol);
- code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy, &fromtid);
+ code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy, &tmp);
+ fromtid = tmp;
EGOTO1(mfail, code, "Failed to create transaction on the volume %u\n",
afromvol);
VDONE;
/* Get a clone id */
VPRINT1("Allocating new volume id for clone of volume %u ...",
afromvol);
- newVol = 0;
- vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &newVol);
+ newVol = tmpVol = 0;
+ vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &tmpVol);
+ newVol = tmpVol;
EGOTO1(mfail, vcode,
"Could not get an ID for the clone of volume %u from the VLDB\n",
afromvol);
VPRINT1("Cloning source volume %u ...", afromvol);
strcpy(vname, "move-clone-temp");
code =
- AFSVolClone(fromconn, fromtid, 0, readonlyVolume, vname, &newVol);
+ AFSVolClone(fromconn, fromtid, 0, readonlyVolume, vname, &tmpVol);
+ newVol = tmpVol;
EGOTO1(mfail, code, "Failed to clone the source volume %u\n",
afromvol);
VDONE;
if (!(flags & RV_NOCLONE)) {
/* All of this is to get the fromDate */
VPRINT1("Starting transaction on the cloned volume %u ...", newVol);
+ tmp = clonetid;
code =
AFSVolTransCreate_retry(fromconn, newVol, afrompart, ITOffline,
- &clonetid);
+ &tmp);
+ clonetid = tmp;
EGOTO1(mfail, code,
"Failed to start a transaction on the cloned volume%u\n",
newVol);
/* create a volume on the target machine */
volid = afromvol;
- code = AFSVolTransCreate_retry(toconn, volid, atopart, ITOffline, &totid);
+ tmp = totid;
+ code = AFSVolTransCreate_retry(toconn, volid, atopart, ITOffline, &tmp);
+ totid = tmp;
if (!code) {
/* Delete the existing volume.
* While we are deleting the volume in these steps, the transaction
}
VPRINT1("Creating the destination volume %u ...", volid);
+ tmp = totid;
+ tmpVol = volid;
code =
- AFSVolCreateVolume(toconn, atopart, volName, volser_RW, volid, &volid,
- &totid);
+ AFSVolCreateVolume(toconn, atopart, volName, volser_RW, volid, &tmpVol,
+ &tmp);
+ totid = tmp;
+ volid = tmpVol;
EGOTO1(mfail, code, "Failed to create the destination volume %u\n",
volid);
VDONE;
* ***/
VPRINT1("Starting transaction on source volume %u ...", afromvol);
- code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy, &fromtid);
+ tmp = fromtid;
+ code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy, &tmp);
+ fromtid = tmp;
EGOTO1(mfail, code,
"Failed to create a transaction on the source volume %u\n",
afromvol);
/* Delete the backup volume on the original site */
VPRINT1("Creating transaction for backup volume %u on source ...",
backupId);
+ tmp = fromtid;
code =
- AFSVolTransCreate_retry(fromconn, backupId, afrompart, ITOffline, &fromtid);
+ AFSVolTransCreate_retry(fromconn, backupId, afrompart, ITOffline, &tmp);
+ fromtid = tmp;
VDONE;
if (!code) {
VPRINT1("Setting flags on backup volume %u on source ...", backupId);
fromtid = 0;
if (!(flags & RV_NOCLONE)) {
VPRINT1("Starting transaction on the cloned volume %u ...", newVol);
+ tmp = clonetid;
code =
AFSVolTransCreate_retry(fromconn, newVol, afrompart, ITOffline,
- &clonetid);
+ &tmp);
+ clonetid = tmp;
EGOTO1(mfail, code,
"Failed to start a transaction on the cloned volume%u\n",
newVol);
}
MapHostToNetwork(&entry);
- /* Delete either the volume on the source location or the target location.
+ /* Delete either the volume on the source location or the target location.
* If the vldb entry still points to the source location, then we know the
- * volume move didn't finish so we remove the volume from the target
+ * volume move didn't finish so we remove the volume from the target
* location. Otherwise, we remove the volume from the source location.
*/
if (Lp_Match(afromserver, afrompart, &entry)) { /* didn't move - delete target volume */
VPRINT1
("Recovery: Creating transaction for destination volume %u ...",
volid);
+ tmp = totid;
code =
- AFSVolTransCreate_retry(toconn, volid, atopart, ITOffline, &totid);
+ AFSVolTransCreate_retry(toconn, volid, atopart, ITOffline, &tmp);
+ totid = tmp;
if (!code) {
VDONE;
if (fromconn) {
VPRINT1("Recovery: Creating transaction on source volume %u ...",
afromvol);
+ tmp = fromtid;
code =
AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy,
- &fromtid);
+ &tmp);
+ fromtid = tmp;
if (!code) {
VDONE;
if (fromconn) {
VPRINT1("Recovery: Creating transaction on backup volume %u ...",
backupId);
+ tmp = fromtid;
code =
AFSVolTransCreate_retry(fromconn, backupId, afrompart, ITOffline,
- &fromtid);
+ &tmp);
+ fromtid = tmp;
if (!code) {
VDONE;
/* delete source volume */
VPRINT1("Recovery: Creating transaction on source volume %u ...",
afromvol);
+ tmp = fromtid;
code =
AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy,
- &fromtid);
+ &tmp);
+ fromtid = tmp;
if (!code) {
VDONE;
if (newVol) {
VPRINT1("Recovery: Creating transaction on clone volume %u ...",
newVol);
+ tmp = clonetid;
code =
AFSVolTransCreate_retry(fromconn, newVol, afrompart, ITOffline,
- &clonetid);
+ &tmp);
+ clonetid = tmp;
if (!code) {
VDONE;
int
-UV_MoveVolume(afs_uint32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
- afs_int32 atoserver, afs_int32 atopart)
+UV_MoveVolume(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
+ afs_uint32 atoserver, afs_int32 atopart)
{
return UV_MoveVolume2(afromvol, afromserver, afrompart,
atoserver, atopart, 0);
* <atopart>. The new volume is named by <atovolname>. The new volume
* has ID <atovolid> if that is nonzero; otherwise a new ID is allocated
* from the VLDB. the following flags are supported:
- *
+ *
* RV_RDONLY - target volume is RO
* RV_OFFLINE - leave target volume offline
* RV_CPINCR - do incremental dump if target exists
* RV_NOCLONE - don't use a copy clone
*/
int
-UV_CopyVolume2(afs_uint32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
- char *atovolname, afs_int32 atoserver, afs_int32 atopart,
+UV_CopyVolume2(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
+ char *atovolname, afs_uint32 atoserver, afs_int32 atopart,
afs_uint32 atovolid, int flags)
{
- struct rx_connection *toconn, *fromconn;
- afs_int32 fromtid, totid, clonetid;
+ /* declare stuff 'volatile' that may be used from setjmp/longjmp and may
+ * be changing during the copy */
+ int volatile pntg;
+ afs_int32 volatile clonetid;
+ afs_int32 volatile totid;
+ afs_int32 volatile fromtid;
+ struct rx_connection * volatile fromconn;
+ struct rx_connection * volatile toconn;
+ afs_uint32 volatile cloneVol;
+
char vname[64];
afs_int32 rcode;
afs_int32 fromDate, cloneFromDate;
struct restoreCookie cookie;
- register afs_int32 vcode, code;
- afs_uint32 cloneVol, newVol;
+ afs_int32 vcode, code;
+ afs_uint32 newVol;
afs_int32 volflag;
struct volser_status tstatus;
struct destServer destination;
-
struct nvldbentry entry, newentry, storeEntry;
- int islocked, pntg;
afs_int32 error;
- int justclone = 0;
+ afs_int32 tmp;
+ afs_uint32 tmpVol;
- islocked = 0;
fromconn = (struct rx_connection *)0;
toconn = (struct rx_connection *)0;
fromtid = 0;
fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT);
fromtid = totid = 0; /* initialize to uncreated */
-
- /* check if we can shortcut and use a local clone instead of a full copy */
- if (afromserver == atoserver && afrompart == atopart) {
- justclone = 1;
- }
-
/* ***
* clone the read/write volume locally.
* ***/
cloneVol = 0;
if (!(flags & RV_NOCLONE)) {
VPRINT1("Starting transaction on source volume %u ...", afromvol);
+ tmp = fromtid;
code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy,
- &fromtid);
+ &tmp);
+ fromtid = tmp;
EGOTO1(mfail, code, "Failed to create transaction on the volume %u\n",
afromvol);
VDONE;
VPRINT1("Allocating new volume id for clone of volume %u ...",
afromvol);
cloneVol = 0;
- vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &cloneVol);
+ tmpVol = cloneVol;
+ vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &tmpVol);
+ cloneVol = tmpVol;
EGOTO1(mfail, vcode,
"Could not get an ID for the clone of volume %u from the VLDB\n",
afromvol);
/* Do the clone. Default flags on clone are set to delete on salvage and out of service */
VPRINT1("Cloning source volume %u ...", afromvol);
strcpy(vname, "copy-clone-temp");
+ tmpVol = cloneVol;
code =
AFSVolClone(fromconn, fromtid, 0, readonlyVolume, vname,
- &cloneVol);
+ &tmpVol);
+ cloneVol = tmpVol;
EGOTO1(mfail, code, "Failed to clone the source volume %u\n",
afromvol);
VDONE;
if (!(flags & RV_NOCLONE)) {
VPRINT1("Starting transaction on the cloned volume %u ...", cloneVol);
+ tmp = clonetid;
code =
AFSVolTransCreate_retry(fromconn, cloneVol, afrompart, ITOffline,
- &clonetid);
+ &tmp);
+ clonetid = tmp;
EGOTO1(mfail, code,
"Failed to start a transaction on the cloned volume%u\n",
cloneVol);
/* create a volume on the target machine */
cloneFromDate = 0;
- code = AFSVolTransCreate_retry(toconn, newVol, atopart, ITOffline, &totid);
+ tmp = totid;
+ code = AFSVolTransCreate_retry(toconn, newVol, atopart, ITOffline, &tmp);
+ totid = tmp;
if (!code) {
if ((flags & RV_CPINCR)) {
VPRINT1("Getting status of pre-existing volume %u ...", newVol);
}
VPRINT1("Creating the destination volume %u ...", newVol);
+ tmp = totid;
code =
AFSVolCreateVolume(toconn, atopart, atovolname,
(flags & RV_RDONLY) ? volser_RO : volser_RW,
- newVol, &newVol, &totid);
+ newVol, &newVol, &tmp);
+ totid = tmp;
EGOTO1(mfail, code, "Failed to create the destination volume %u\n",
newVol);
VDONE;
* ***/
VPRINT1("Starting transaction on source volume %u ...", afromvol);
- code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy, &fromtid);
+ tmp = fromtid;
+ code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy, &tmp);
+ fromtid = tmp;
EGOTO1(mfail, code,
"Failed to create a transaction on the source volume %u\n",
afromvol);
if (!(flags & RV_NOCLONE)) {
VPRINT1("Starting transaction on the cloned volume %u ...", cloneVol);
+ tmp = clonetid;
code =
AFSVolTransCreate_retry(fromconn, cloneVol, afrompart, ITOffline,
- &clonetid);
+ &tmp);
+ clonetid = tmp;
EGOTO1(mfail, code,
"Failed to start a transaction on the cloned volume%u\n",
cloneVol);
if (cloneVol) {
VPRINT1("Recovery: Creating transaction on clone volume %u ...",
cloneVol);
+ tmp = clonetid;
code =
AFSVolTransCreate_retry(fromconn, cloneVol, afrompart, ITOffline,
- &clonetid);
+ &tmp);
+ clonetid = tmp;
if (!code) {
VDONE;
int
-UV_CopyVolume(afs_uint32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
- char *atovolname, afs_int32 atoserver, afs_int32 atopart)
+UV_CopyVolume(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
+ char *atovolname, afs_uint32 atoserver, afs_int32 atopart)
{
return UV_CopyVolume2(afromvol, afromserver, afrompart,
atovolname, atoserver, atopart, 0, 0);
-/* Make a new backup of volume <avolid> on <aserver> and <apart>
- * if one already exists, update it
+/* Make a new backup of volume <avolid> on <aserver> and <apart>
+ * if one already exists, update it
*/
int
-UV_BackupVolume(afs_int32 aserver, afs_int32 apart, afs_uint32 avolid)
+UV_BackupVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid)
{
struct rx_connection *aconn = (struct rx_connection *)0;
afs_int32 ttid = 0, btid = 0;
backupID = entry.volumeId[BACKVOL];
if (backupID == INVALID_BID) {
/* Get a backup volume id from the VLDB and update the vldb
- * entry with it.
+ * entry with it.
*/
code = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &backupID);
if (code) {
}
/* Now go ahead and try to clone the RW volume.
- * First start a transaction on the RW volume
+ * First start a transaction on the RW volume
*/
code = AFSVolTransCreate_retry(aconn, avolid, apart, ITBusy, &ttid);
if (code) {
goto bfail;
}
- /* Clone or reclone the volume, depending on whether the backup
+ /* Clone or reclone the volume, depending on whether the backup
* volume exists or not
*/
if (backexists) {
return error;
}
-/* Make a new clone of volume <avolid> on <aserver> and <apart>
+/* Make a new clone of volume <avolid> on <aserver> and <apart>
* using volume ID <acloneid>, or a new ID allocated from the VLDB.
* The new volume is named by <aname>, or by appending ".clone" to
* the existing name if <aname> is NULL. The following flags are
* supported:
- *
+ *
* RV_RDONLY - target volume is RO
* RV_OFFLINE - leave target volume offline
*/
int
-UV_CloneVolume(afs_int32 aserver, afs_int32 apart, afs_uint32 avolid,
+UV_CloneVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid,
afs_uint32 acloneid, char *aname, int flags)
{
struct rx_connection *aconn = (struct rx_connection *)0;
}
/* Now go ahead and try to clone the RW volume.
- * First start a transaction on the RW volume
+ * First start a transaction on the RW volume
*/
code = AFSVolTransCreate_retry(aconn, avolid, apart, ITBusy, &ttid);
if (code) {
goto bfail;
}
- /* Clone or reclone the volume, depending on whether the backup
+ /* Clone or reclone the volume, depending on whether the backup
* volume exists or not
*/
if (backexists) {
}
#define ONERROR(ec, ep, es) if (ec) { fprintf(STDERR, (es), (ep)); error = (ec); goto rfail; }
+#define ONERROR0(ec, es) if (ec) { fprintf(STDERR, (es)); error = (ec); goto rfail; }
#define ERROREXIT(ec) { error = (ec); goto rfail; }
-/* Get a "transaction" on this replica. Create the volume
+/* Get a "transaction" on this replica. Create the volume
* if necessary. Return the time from which a dump should
* be made (0 if it's a new volume)
*/
static int
GetTrans(struct nvldbentry *vldbEntryPtr, afs_int32 index,
struct rx_connection **connPtr, afs_int32 * transPtr,
- afs_int32 * crtimePtr, afs_int32 * uptimePtr)
+ afs_uint32 * crtimePtr, afs_uint32 * uptimePtr)
{
afs_uint32 volid;
struct volser_status tstatus;
}
/* Otherwise, the transaction did succeed, so get the creation date of the
- * latest RO volume on the replication site
+ * latest RO volume on the replication site
*/
else {
VPRINT2("Updating existing ro volume %u on %s ...\n", volid,
noresolve ? afs_inet_ntoa_r(vldbEntryPtr->
- serverNumber[index], hoststr) :
+ serverNumber[index], hoststr) :
hostutil_GetNameByINet(vldbEntryPtr->serverNumber[index]));
code = AFSVolGetStatus(*connPtr, *transPtr, &tstatus);
* successfully.
* forceflag: Performs a full release.
*
- * Will create a clone from the RW, then dump the clone out to
+ * Will create a clone from the RW, then dump the clone out to
* the remaining replicas. If there is more than 1 RO sites,
* ensure that the VLDB says at least one RO is available all
* the time: Influences when we write back the VLDB entry.
*/
int
-UV_ReleaseVolume(afs_uint32 afromvol, afs_int32 afromserver,
+UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
afs_int32 afrompart, int forceflag)
{
char vname[64];
manyResults results;
int rwindex, roindex, roclone, roexists;
afs_uint32 rwcrdate = 0;
- afs_uint32 rwupdate, clcrdate;
+ afs_uint32 clcrdate;
struct rtime {
int validtime;
afs_uint32 uptime;
struct volser_status volstatus;
char hoststr[16];
- memset((char *)remembertime, 0, sizeof(remembertime));
- memset((char *)&results, 0, sizeof(results));
+ memset(remembertime, 0, sizeof(remembertime));
+ memset(&results, 0, sizeof(results));
vcode = ubik_VL_SetLock(cstruct, 0, afromvol, RWVOL, VLOP_RELEASE);
if (vcode != VL_RERELEASE)
roclone = ((roindex == -1) ? 0 : 1);
rwindex = Lp_GetRwIndex(&entry);
if (rwindex < 0)
- ONERROR(VOLSERNOVOL, 0, "There is no RW volume \n");
+ ONERROR0(VOLSERNOVOL, "There is no RW volume \n");
/* Make sure we have a RO volume id to work with */
if (entry.volumeId[ROVOL] == INVALID_BID) {
ONERROR(code, afromvol,
"Failed to get the status of RW volume %u\n");
rwcrdate = volstatus.creationDate;
- rwupdate = volstatus.updateDate;
/* End transaction on RW */
code = AFSVolEndTrans(fromconn, fromtid, &rcode);
"Failed to get the status of the RW volume %u\n");
VDONE;
rwcrdate = volstatus.creationDate;
- rwupdate = volstatus.updateDate;
/* End the transaction on the RW volume */
VPRINT1("Ending cloning transaction on RW volume %u...", afromvol);
ONERROR(tcode, cloneVolId, "Could not bring volume %u on line\n");
/* Sleep so that a client searching for an online volume won't
- * find the clone offline and then the next RO offline while the
+ * find the clone offline and then the next RO offline while the
* release brings the clone online and the next RO offline (race).
* There is a fix in the 3.4 client that does not need this sleep
* anymore, but we don't know what clients we have.
results.manyResults_val =
(afs_int32 *) malloc(sizeof(afs_int32) * nservers + 1);
if (!replicas || !times || !!!results.manyResults_val || !toconns)
- ONERROR(ENOMEM, 0,
+ ONERROR0(ENOMEM,
"Failed to create transaction on the release clone\n");
memset(replicas, 0, (sizeof(struct replica) * nservers + 1));
if (!fullrelease && code)
ONERROR(VOLSERNOVOL, afromvol,
"Old clone is inaccessible. Try vos release -f %u.\n");
- ONERROR(code, 0, "Failed to create transaction on the release clone\n");
+ ONERROR0(code, "Failed to create transaction on the release clone\n");
VDONE;
/* For each index in the VLDB */
/* Get a Transaction on this replica. Get a new connection if
* necessary. Create the volume if necessary. Return the
* time from which the dump should be made (0 if it's a new
- * volume). Each volume might have a different time.
+ * volume). Each volume might have a different time.
*/
replicas[volcount].server.destHost =
ntohl(entry.serverNumber[vldbindex]);
/* have to clear dest. flags to ensure new vol goes online:
* because the restore (forwarded) operation copied
- * the V_inService(=0) flag over to the destination.
+ * the V_inService(=0) flag over to the destination.
*/
code = AFSVolSetFlags(toconns[m], replicas[m].trans, 0);
if (code) {
/* Dump the volume <afromvol> on <afromserver> and
* <afrompart> to <afilename> starting from <fromdate>.
* DumpFunction does the real work behind the scenes after
- * extracting parameters from the rock
+ * extracting parameters from the rock
*/
int
-UV_DumpVolume(afs_uint32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
+UV_DumpVolume(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
afs_int32 fromdate,
afs_int32(*DumpFunction) (struct rx_call *, void *), void *rock,
afs_int32 flags)
{
- struct rx_connection *fromconn = (struct rx_connection *)0;
- struct rx_call *fromcall = (struct rx_call *)0;
- afs_int32 fromtid = 0, rxError = 0, rcode = 0;
- afs_int32 code, error = 0, retry = 0;
+ /* declare stuff 'volatile' that may be used from setjmp/longjmp and may
+ * be changing during the dump */
+ struct rx_call * volatile fromcall = NULL;
+ struct rx_connection * volatile fromconn = NULL;
+ afs_int32 volatile fromtid = 0;
+
+ afs_int32 rxError = 0, rcode = 0;
+ afs_int32 code, error = 0;
+ afs_int32 tmp;
time_t tmv = fromdate;
if (setjmp(env))
fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT);
VEPRINT1("Starting transaction on volume %u...", afromvol);
- code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy, &fromtid);
+ tmp = fromtid;
+ code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy, &tmp);
+ fromtid = tmp;
EGOTO1(error_exit, code,
"Could not start transaction on the volume %u to be dumped\n",
afromvol);
fromcall = rx_NewCall(fromconn);
VEPRINT1("Starting volume dump on volume %u...", afromvol);
- if (flags & VOLDUMPV2_OMITDIRS)
+ if (flags & VOLDUMPV2_OMITDIRS)
code = StartAFSVolDumpV2(fromcall, fromtid, fromdate, flags);
else
- retryold:
code = StartAFSVolDump(fromcall, fromtid, fromdate);
EGOTO(error_exit, code, "Could not start the dump process \n");
VEDONE;
VEPRINT1("Dumping volume %u...", afromvol);
code = DumpFunction(fromcall, rock);
- if (code == RXGEN_OPCODE)
+ if (code == RXGEN_OPCODE)
goto error_exit;
EGOTO(error_exit, code, "Error while dumping volume \n");
VEDONE;
error_exit:
if (fromcall) {
code = rx_EndCall(fromcall, rxError);
- if (code && code != RXGEN_OPCODE)
+ if (code && code != RXGEN_OPCODE)
fprintf(STDERR, "Error in rx_EndCall\n");
if (code && !error)
error = code;
if (fromconn)
rx_DestroyConnection(fromconn);
- if (retry)
- goto retryold;
if (error != RXGEN_OPCODE)
PrintError("", error);
return (error);
}
/* Clone the volume <afromvol> on <afromserver> and
- * <afrompart>, and then dump the clone volume to
+ * <afrompart>, and then dump the clone volume to
* <afilename> starting from <fromdate>.
* DumpFunction does the real work behind the scenes after
- * extracting parameters from the rock
+ * extracting parameters from the rock
*/
int
-UV_DumpClonedVolume(afs_uint32 afromvol, afs_int32 afromserver,
+UV_DumpClonedVolume(afs_uint32 afromvol, afs_uint32 afromserver,
afs_int32 afrompart, afs_int32 fromdate,
afs_int32(*DumpFunction) (struct rx_call *, void *),
void *rock, afs_int32 flags)
{
- struct rx_connection *fromconn = (struct rx_connection *)0;
- struct rx_call *fromcall = (struct rx_call *)0;
+ /* declare stuff 'volatile' that may be used from setjmp/longjmp and may
+ * be changing during the dump */
+ struct rx_connection * volatile fromconn = NULL;
+ struct rx_call * volatile fromcall = NULL;
+ afs_int32 volatile clonetid = 0;
+ afs_uint32 volatile clonevol = 0;
+
+ afs_int32 tmp;
afs_int32 fromtid = 0, rxError = 0, rcode = 0;
- afs_int32 clonetid = 0;
afs_int32 code = 0, error = 0;
- afs_uint32 clonevol = 0;
+ afs_uint32 tmpVol;
char vname[64];
time_t tmv = fromdate;
/* Get a clone id */
VEPRINT1("Allocating new volume id for clone of volume %u ...", afromvol);
- code = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &clonevol);
+ tmpVol = clonevol;
+ code = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &tmpVol);
+ clonevol = tmpVol;
EGOTO1(error_exit, code,
"Could not get an ID for the clone of volume %u from the VLDB\n",
afromvol);
VEPRINT2("Cloning source volume %u to clone volume %u...", afromvol,
clonevol);
strcpy(vname, "dump-clone-temp");
+ tmpVol = clonevol;
code =
- AFSVolClone(fromconn, fromtid, 0, readonlyVolume, vname, &clonevol);
+ AFSVolClone(fromconn, fromtid, 0, readonlyVolume, vname, &tmpVol);
+ clonevol = tmpVol;
EGOTO1(error_exit, code, "Failed to clone the source volume %u\n",
afromvol);
VEDONE;
VEPRINT1("Starting transaction on the cloned volume %u ...", clonevol);
+ tmp = clonetid;
code =
AFSVolTransCreate_retry(fromconn, clonevol, afrompart, ITOffline,
- &clonetid);
+ &tmp);
+ clonetid = tmp;
EGOTO1(error_exit, code,
"Failed to start a transaction on the cloned volume%u\n",
clonevol);
fromcall = rx_NewCall(fromconn);
VEPRINT1("Starting volume dump from cloned volume %u...", clonevol);
- if (flags & VOLDUMPV2_OMITDIRS)
+ if (flags & VOLDUMPV2_OMITDIRS)
code = StartAFSVolDumpV2(fromcall, clonetid, fromdate, flags);
else
code = StartAFSVolDump(fromcall, clonetid, fromdate);
/*
* Restore a volume <tovolid> <tovolname> on <toserver> <topart> from
* the dump file <afilename>. WriteData does all the real work
- * after extracting params from the rock
+ * after extracting params from the rock
*/
int
-UV_RestoreVolume2(afs_int32 toserver, afs_int32 topart, afs_uint32 tovolid,
- afs_int32 toparentid, char tovolname[], int flags,
+UV_RestoreVolume2(afs_uint32 toserver, afs_int32 topart, afs_uint32 tovolid,
+ afs_uint32 toparentid, char tovolname[], int flags,
afs_int32(*WriteData) (struct rx_call *, void *),
void *rock)
{
struct volintInfo vinfo;
char partName[10];
char tovolreal[VOLSER_OLDMAXVOLNAME];
- afs_uint32 pvolid;
+ afs_uint32 pvolid;
afs_int32 temptid, pparentid;
int success;
struct nvldbentry entry, storeEntry;
if (!pparentid) pparentid = pvolid;
/* at this point we have a volume id to use/reuse for the volume to be restored */
strncpy(tovolreal, tovolname, VOLSER_OLDMAXVOLNAME);
-
+
if (strlen(tovolname) > (VOLSER_OLDMAXVOLNAME - 1)) {
EGOTO1(refail, VOLSERBADOP,
"The volume name %s exceeds the maximum limit of (VOLSER_OLDMAXVOLNAME -1 ) bytes\n",
fprintf(STDOUT, " done\n");
fflush(STDOUT);
if (success && (!reuseID || (flags & RV_FULLRST))) {
- /* Volume was restored on the file server, update the
+ /* Volume was restored on the file server, update the
* VLDB to reflect the change.
*/
vcode = VLDB_GetEntryByID(pvolid, voltype, &entry);
tempconn =
UV_Bind(entry.serverNumber[index],
AFSCONF_VOLUMEPORT);
-
+
MapPartIdIntoName(entry.serverPartition[index],
apartName);
VPRINT3
}
int
-UV_RestoreVolume(afs_int32 toserver, afs_int32 topart, afs_uint32 tovolid,
+UV_RestoreVolume(afs_uint32 toserver, afs_int32 topart, afs_uint32 tovolid,
char tovolname[], int flags,
afs_int32(*WriteData) (struct rx_call *, void *),
void *rock)
}
+/* old interface to add rosites */
+int
+UV_AddSite(afs_uint32 server, afs_int32 part, afs_uint32 volid,
+ afs_int32 valid)
+{
+ return UV_AddSite2(server, part, volid, 0, valid);
+}
+
/*adds <server> and <part> as a readonly replication site for <volid>
*in vldb */
int
-UV_AddSite(afs_int32 server, afs_int32 part, afs_uint32 volid, afs_int32 valid)
+UV_AddSite2(afs_uint32 server, afs_int32 part, afs_uint32 volid,
+ afs_uint32 rovolid, afs_int32 valid)
{
int j, nro = 0, islocked = 0;
- struct nvldbentry entry, storeEntry;
+ struct nvldbentry entry, storeEntry, entry2;
afs_int32 vcode, error = 0;
char apartName[10];
goto asfail;
}
+ /* if rovolid == 0, we leave the RO volume id alone. If the volume doesn't
+ * have an RO volid at this point (i.e. entry.volumeId[ROVOL] ==
+ * INVALID_BID) and we leave it alone, it gets an RO volid at release-time.
+ */
+ if (rovolid) {
+ if (entry.volumeId[ROVOL] == INVALID_BID) {
+ vcode = VLDB_GetEntryByID(rovolid, -1, &entry2);
+ if (!vcode) {
+ fprintf(STDERR, "Volume ID %d already exists\n", rovolid);
+ return VVOLEXISTS;
+ }
+ VPRINT1("Using RO volume id %d.\n", rovolid);
+ entry.volumeId[ROVOL] = rovolid;
+ } else {
+ fprintf(STDERR, "Ignoring given RO id %d, since volume already has RO id %d\n",
+ rovolid, entry.volumeId[ROVOL]);
+ }
+ }
+
VPRINT("Adding a new site ...");
entry.serverNumber[entry.nServers] = server;
entry.serverPartition[entry.nServers] = part;
/*removes <server> <part> as read only site for <volid> from the vldb */
int
-UV_RemoveSite(afs_int32 server, afs_int32 part, afs_uint32 volid)
+UV_RemoveSite(afs_uint32 server, afs_int32 part, afs_uint32 volid)
{
afs_int32 vcode;
struct nvldbentry entry, storeEntry;
- int islocked;
vcode = ubik_VL_SetLock(cstruct, 0, volid, RWVOL, VLOP_ADDSITE);
if (vcode) {
PrintError("", vcode);
return (vcode);
}
- islocked = 1;
vcode = VLDB_GetEntryByID(volid, RWVOL, &entry);
if (vcode) {
fprintf(STDERR,
/*sets <server> <part> as read/write site for <volid> in the vldb */
int
-UV_ChangeLocation(afs_int32 server, afs_int32 part, afs_uint32 volid)
+UV_ChangeLocation(afs_uint32 server, afs_int32 part, afs_uint32 volid)
{
afs_int32 vcode;
struct nvldbentry entry, storeEntry;
/*list all the partitions on <aserver> */
int
-UV_ListPartitions(afs_int32 aserver, struct partList *ptrPartList,
+UV_ListPartitions(afs_uint32 aserver, struct partList *ptrPartList,
afs_int32 * cntp)
{
struct rx_connection *aconn;
struct pIDs partIds;
struct partEntries partEnts;
- register int i, j = 0, code;
+ int i, j = 0, code;
*cntp = 0;
aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT);
/*zap the list of volumes specified by volPtrArray (the volCloneId field).
This is used by the backup system */
int
-UV_ZapVolumeClones(afs_int32 aserver, afs_int32 apart,
+UV_ZapVolumeClones(afs_uint32 aserver, afs_int32 apart,
struct volDescription *volPtr, afs_int32 arraySize)
{
struct rx_connection *aconn;
return 0;
}
-/*return a list of clones of the volumes specified by volPtrArray. Used by the
+/*return a list of clones of the volumes specified by volPtrArray. Used by the
backup system */
int
-UV_GenerateVolumeClones(afs_int32 aserver, afs_int32 apart,
+UV_GenerateVolumeClones(afs_uint32 aserver, afs_int32 apart,
struct volDescription *volPtr, afs_int32 arraySize)
{
struct rx_connection *aconn;
/*list all the volumes on <aserver> and <apart>. If all = 1, then all the
* relevant fields of the volume are also returned. This is a heavy weight operation.*/
int
-UV_ListVolumes(afs_int32 aserver, afs_int32 apart, int all,
+UV_ListVolumes(afs_uint32 aserver, afs_int32 apart, int all,
struct volintInfo **resultPtr, afs_int32 * size)
{
struct rx_connection *aconn;
*------------------------------------------------------------------------*/
int
-UV_XListVolumes(afs_int32 a_serverID, afs_int32 a_partID, int a_all,
+UV_XListVolumes(afs_uint32 a_serverID, afs_int32 a_partID, int a_all,
struct volintXInfo **a_resultPP,
afs_int32 * a_numEntsInResultP)
{
/* get all the information about volume <volid> on <aserver> and <apart> */
int
-UV_ListOneVolume(afs_int32 aserver, afs_int32 apart, afs_uint32 volid,
+UV_ListOneVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 volid,
struct volintInfo **resultPtr)
{
struct rx_connection *aconn;
*------------------------------------------------------------------------*/
int
-UV_XListOneVolume(afs_int32 a_serverID, afs_int32 a_partID, afs_uint32 a_volID,
+UV_XListOneVolume(afs_uint32 a_serverID, afs_int32 a_partID, afs_uint32 a_volID,
struct volintXInfo **a_resultPP)
{
struct rx_connection *rxConnP; /*Rx connection to Volume Server */
}
/* CheckVolume()
- * Given a volume we read from a partition, check if it is
+ * Given a volume we read from a partition, check if it is
* represented in the VLDB correctly.
- *
+ *
* The VLDB is looked up by the RW volume id (not its name).
* The RW contains the true name of the volume (BK and RO set
* the name in the VLDB only on creation of the VLDB entry).
* We want rules strict enough that when we check all volumes
* on one partition, it does not need to be done again. IE:
- * two volumes on different partitions won't constantly
+ * two volumes on different partitions won't constantly
* change a VLDB entry away from what the other set.
- * For RW and BK volumes, we will always check the VLDB to see
+ * For RW and BK volumes, we will always check the VLDB to see
* if the two exist on the server/partition. May seem redundant,
* but this is an easy check of the VLDB. IE: if the VLDB entry
* says the BK exists but no BK volume is there, we will detect
* Output changed to look a lot like the "vos syncserv" otuput.
*/
static afs_int32
-CheckVolume(volintInfo * volumeinfo, afs_int32 aserver, afs_int32 apart,
- afs_int32 * modentry, afs_uint32 * maxvolid)
+CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver, afs_int32 apart,
+ afs_int32 * modentry, afs_uint32 * maxvolid,
+ struct nvldbentry *aentry)
{
int idx = 0;
int j;
afs_int32 code, error = 0;
struct nvldbentry entry, storeEntry;
char pname[10];
- int pass = 0, islocked = 0, createentry, addvolume, modified, mod, doit = 1;
+ int pass = 0, createentry, addvolume, modified, mod, doit = 1;
afs_uint32 rwvolid;
- char hoststr[16];
+ char hoststr[16];
if (modentry) {
if (*modentry == 1)
(unsigned long)rwvolid);
ERROR_EXIT(code);
}
- islocked = 1;
}
createentry = 0; /* Do we need to create a VLDB entry */
addvolume = 0; /* Add this volume to the VLDB entry */
modified = 0; /* The VLDB entry was modified */
- /* Read the entry from VLDB by its RW volume id */
- code = VLDB_GetEntryByID(rwvolid, RWVOL, &entry);
- if (code) {
- if (code != VL_NOENT) {
- fprintf(STDOUT,
- "Could not retreive the VLDB entry for volume %lu \n",
- (unsigned long)rwvolid);
- ERROR_EXIT(code);
- }
+ if (aentry) {
+ memcpy(&entry, aentry, sizeof(entry));
+ } else {
+ /* Read the entry from VLDB by its RW volume id */
+ code = VLDB_GetEntryByID(rwvolid, RWVOL, &entry);
+ if (code) {
+ if (code != VL_NOENT) {
+ fprintf(STDOUT,
+ "Could not retreive the VLDB entry for volume %lu \n",
+ (unsigned long)rwvolid);
+ ERROR_EXIT(code);
+ }
- memset(&entry, 0, sizeof(entry));
- vsu_ExtractName(entry.name, volumeinfo->name); /* Store name of RW */
+ memset(&entry, 0, sizeof(entry));
+ vsu_ExtractName(entry.name, volumeinfo->name); /* Store name of RW */
- createentry = 1;
- } else {
- MapHostToNetwork(&entry);
+ createentry = 1;
+ } else {
+ MapHostToNetwork(&entry);
+ }
}
if (verbose && (pass == 1)) {
fprintf(STDERR,
" VLDB reports RW volume %lu exists on %s %s\n",
(unsigned long)rwvolid,
- noresolve ?
+ noresolve ?
afs_inet_ntoa_r(entry.serverNumber[idx], hoststr) :
hostutil_GetNameByINet(entry.
serverNumber[idx]),
fprintf(STDERR,
" VLDB reports its RW volume %lu exists on %s %s\n",
(unsigned long)rwvolid,
- noresolve ?
+ noresolve ?
afs_inet_ntoa_r(aserver, hoststr) :
hostutil_GetNameByINet(aserver),
pname);
else if (volumeinfo->type == ROVOL) { /* A RO volume */
if (volumeinfo->volid == entry.volumeId[ROVOL]) {
- /* This is a quick check to see if the RO entry exists in the
+ /* This is a quick check to see if the RO entry exists in the
* VLDB so we avoid the CheckVldbRO() call (which checks if each
* RO volume listed in the VLDB exists).
*/
ERROR_EXIT(code);
}
}
- if (modentry)
- *modentry = modified;
} else if (pass == 2) {
code =
ubik_VL_ReleaseLock(cstruct, 0, rwvolid, RWVOL,
}
}
- if (verbose && doit) {
+ if (modified && modentry) {
+ *modentry = 1;
+ }
+
+ if (aentry) {
+ memcpy(aentry, &entry, sizeof(entry));
+ }
+
+ if (verbose) {
fprintf(STDOUT, "-- status after --\n");
if (modified)
EnumerateEntry(&entry);
* if the volume exists on specified servers (similar to syncvldb).
*/
int
-UV_SyncVolume(afs_int32 aserver, afs_int32 apart, char *avolname, int flags)
+UV_SyncVolume(afs_uint32 aserver, afs_int32 apart, char *avolname, int flags)
{
struct rx_connection *aconn = 0;
afs_int32 j, k, code, vcode, error = 0;
afs_int32 tverbose;
- afs_int32 mod, modified = 0;
+ afs_int32 mod, modified = 0, deleted = 0;
struct nvldbentry vldbentry;
afs_uint32 volumeid = 0;
volEntries volumeInfo;
struct partList PartList;
- afs_int32 pcnt, rv;
+ afs_int32 pcnt;
afs_uint32 maxvolid = 0;
volumeInfo.volEntries_val = (volintInfo *) 0;
/* Turn verbose logging off and do our own verbose logging */
/* tverbose must be set before we call ERROR_EXIT() */
-
+
tverbose = verbose;
- if (flags & 2)
+ if (flags & 2)
tverbose = 1;
verbose = 0;
fprintf(STDOUT, "\n");
}
- /* Verify that all of the VLDB entries exist on the repective servers
+ /* Verify that all of the VLDB entries exist on the repective servers
* and partitions (this does not require that avolname be a volume ID).
* Equivalent to a syncserv.
*/
mod = 1;
else
mod = 0;
- code = CheckVldb(&vldbentry, &mod);
+ code = CheckVldb(&vldbentry, &mod, &deleted);
if (code) {
fprintf(STDERR, "Could not process VLDB entry for volume %s\n",
vldbentry.name);
/* Found one, sync it with VLDB entry */
code =
CheckVolume(volumeInfo.volEntries_val, aserver,
- PartList.partId[j], &mod, &maxvolid);
+ PartList.partId[j], &mod, &maxvolid, &vldbentry);
if (code)
ERROR_EXIT(code);
if (mod)
/* Check to see if the RW, BK, and RO IDs exist on any
* partitions. We get the volume IDs from the VLDB.
*/
- rv = 1; /* Read the VLDB entry ? */
for (j = 0; j < MAXTYPES; j++) { /* for RW, RO, and BK IDs */
- if (rv) {
- vcode = VLDB_GetEntryByName(avolname, &vldbentry);
- if (vcode) {
- if (vcode == VL_NOENT)
- break;
- fprintf(STDERR,
- "Could not access the VLDB for volume %s\n",
- avolname);
- ERROR_EXIT(vcode);
- }
- rv = 0;
- }
-
if (vldbentry.volumeId[j] == 0)
continue;
/* Found one, sync it with VLDB entry */
code =
CheckVolume(volumeInfo.volEntries_val, aserver,
- PartList.partId[k], &mod, &maxvolid);
+ PartList.partId[k], &mod, &maxvolid, &vldbentry);
if (code)
ERROR_EXIT(code);
if (mod)
- modified++, rv++;
+ modified++;
}
if (volumeInfo.volEntries_val)
/* if (aserver) */
/* If verbose output, print a summary of what changed */
- if (tverbose && !(flags & 2)) {
+ if (tverbose) {
fprintf(STDOUT, "-- status after --\n");
- code = VLDB_GetEntryByName(avolname, &vldbentry);
- if (code && (code != VL_NOENT)) {
- fprintf(STDERR, "Could not access the VLDB for volume %s\n",
- avolname);
- ERROR_EXIT(code);
- }
- if (modified && (code == VL_NOENT)) {
+ if (deleted) {
fprintf(STDOUT, "\n**entry deleted**\n");
} else if (modified) {
EnumerateEntry(&vldbentry);
* optionally, <apart>.
*/
int
-UV_SyncVldb(afs_int32 aserver, afs_int32 apart, int flags, int force)
+UV_SyncVldb(afs_uint32 aserver, afs_int32 apart, int flags, int force)
{
struct rx_connection *aconn;
afs_int32 code, error = 0;
modified = 1;
else
modified = 0;
- code = CheckVolume(vi, aserver, apart, &modified, &maxvolid);
+ code = CheckVolume(vi, aserver, apart, &modified, &maxvolid, NULL);
if (code) {
PrintError("", code);
failures++;
} /* thru all partitions */
if (flags & 2) {
- VPRINT3("Total entries: %u, Failed to process %d, Would change %d\n",
+ VPRINT3("Total entries: %u, Failed to process %d, Would change %d\n",
tentries, failures, modifications);
} else {
- VPRINT3("Total entries: %u, Failed to process %d, Changed %d\n",
+ VPRINT3("Total entries: %u, Failed to process %d, Changed %d\n",
tentries, failures, modifications);
}
* still exists - so we catch these error codes.
*/
afs_int32
-VolumeExists(afs_int32 server, afs_int32 partition, afs_uint32 volumeid)
+VolumeExists(afs_uint32 server, afs_int32 partition, afs_uint32 volumeid)
{
struct rx_connection *conn = (struct rx_connection *)0;
afs_int32 code = -1;
*modified = 0;
/* Check to see if the RO volumes exist and set the RO_EXISTS
- * flag accordingly.
+ * flag accordingly.
*/
for (idx = 0; idx < entry->nServers; idx++) {
if (!(entry->serverFlags[idx] & ITSROVOL)) {
* Ensure that <entry> matches with the info on file servers
*/
afs_int32
-CheckVldb(struct nvldbentry * entry, afs_int32 * modified)
+CheckVldb(struct nvldbentry * entry, afs_int32 * modified, afs_int32 * deleted)
{
afs_int32 code, error = 0;
struct nvldbentry storeEntry;
int pass = 0, doit=1;
if (modified) {
- if (*modified == 1)
+ if (*modified == 1)
doit = 0;
*modified = 0;
}
if (mod)
modentry++;
- /* The VLDB entry has been updated. If it as been modified, then
+ /* The VLDB entry has been updated. If it as been modified, then
* write the entry back out the the VLDB.
*/
if (modentry && doit) {
ERROR_EXIT(code);
}
}
- if (modified)
- *modified = 1;
islocked = 0;
}
- if (verbose && doit) {
+ if (modified && modentry) {
+ *modified = 1;
+ }
+ if (deleted && delentry) {
+ *deleted = 1;
+ }
+
+ if (verbose) {
fprintf(STDOUT, "-- status after --\n");
if (delentry)
fprintf(STDOUT, "\n**entry deleted**\n");
* Synchronise <aserver> <apart>(if flags = 1) with the VLDB.
*/
int
-UV_SyncServer(afs_int32 aserver, afs_int32 apart, int flags, int force)
+UV_SyncServer(afs_uint32 aserver, afs_int32 apart, int flags, int force)
{
struct rx_connection *aconn;
afs_int32 code, error = 0;
struct nvldbentry *vlentry;
afs_int32 si, nsi, j;
- if (flags & 2)
+ if (flags & 2)
verbose = 1;
aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT);
modified = 1;
else
modified = 0;
- code = CheckVldb(vlentry, &modified);
+ code = CheckVldb(vlentry, &modified, NULL);
if (code) {
PrintError("", code);
fprintf(STDERR,
VPRINT3("Total entries: %u, Failed to process %d, Would change %d\n",
tentries, failures, modifications);
} else {
- VPRINT3("Total entries: %u, Failed to process %d, Changed %d\n",
+ VPRINT3("Total entries: %u, Failed to process %d, Changed %d\n",
tentries, failures, modifications);
}
return error;
}
-/*rename volume <oldname> to <newname>, changing the names of the related
+/*rename volume <oldname> to <newname>, changing the names of the related
*readonly and backup volumes. This operation is also idempotent.
*salvager is capable of recovering from rename operation stopping halfway.
*to recover run syncserver on the affected machines,it will force renaming to completion. name clashes should have been detected before calling this proc */
goto rvfail;
}
VPRINT1("Recorded the new name %s in VLDB\n", newname);
- /*at this stage the intent to rename is recorded in the vldb, as far as the vldb
+ /*at this stage the intent to rename is recorded in the vldb, as far as the vldb
* is concerned, oldname is lost */
if (entry->flags & RW_EXISTS) {
index = Lp_GetRwIndex(entry);
/*report on all the active transactions on volser */
int
-UV_VolserStatus(afs_int32 server, transDebugInfo ** rpntr, afs_int32 * rcount)
+UV_VolserStatus(afs_uint32 server, transDebugInfo ** rpntr, afs_int32 * rcount)
{
struct rx_connection *aconn;
transDebugEntries transInfo;
/*delete the volume without interacting with the vldb */
int
-UV_VolumeZap(afs_int32 server, afs_int32 part, afs_uint32 volid)
+UV_VolumeZap(afs_uint32 server, afs_int32 part, afs_uint32 volid)
{
afs_int32 rcode, ttid, error, code;
struct rx_connection *aconn;
}
int
-UV_SetVolume(afs_int32 server, afs_int32 partition, afs_uint32 volid,
+UV_SetVolume(afs_uint32 server, afs_int32 partition, afs_uint32 volid,
afs_int32 transflag, afs_int32 setflag, int sleeptime)
{
struct rx_connection *conn = 0;
}
int
-UV_SetVolumeInfo(afs_int32 server, afs_int32 partition, afs_uint32 volid,
+UV_SetVolumeInfo(afs_uint32 server, afs_int32 partition, afs_uint32 volid,
volintInfo * infop)
{
struct rx_connection *conn = 0;
}
int
-UV_GetSize(afs_uint32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
+UV_GetSize(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
afs_int32 fromdate, struct volintSize *vol_size)
{
struct rx_connection *aconn = (struct rx_connection *)0;
git://git.openafs.org / openafs.git / blobdiff