/*
* 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>
-RCSID
- ("$Header$");
+#include <afs/procmgmt.h> /* signal(), kill(), wait(), etc. */
+#include <roken.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <string.h>
#ifdef AFS_AIX_ENV
#include <sys/statfs.h>
#endif
-#ifdef AFS_NT40_ENV
-#include <fcntl.h>
-#include <winsock2.h>
-#else
-#include <sys/file.h>
-#include <netinet/in.h>
-#endif
#include <lock.h>
#include <afs/voldefs.h>
#include <rx/xdr.h>
#include <rx/rx.h>
+#include <rx/rx_queue.h>
#include <afs/vlserver.h>
#include <afs/nfs.h>
#include <afs/cellconfig.h>
#include <rx/rxkad.h>
#include <afs/kautils.h>
#include <afs/cmd.h>
-#include <errno.h>
+#include <afs/ihandle.h>
+#ifdef AFS_NT40_ENV
+#include <afs/ntops.h>
+#endif
+#include <afs/vnode.h>
+#include <afs/volume.h>
#define ERRCODE_RANGE 8 /* from error_table.h */
#define CLOCKSKEW 2 /* not really skew, but resolution */
#define CLOCKADJ(x) (((x) < CLOCKSKEW) ? 0 : (x) - CLOCKSKEW)
/* for UV_MoveVolume() recovery */
-#include <afs/procmgmt.h> /* signal(), kill(), wait(), etc. */
#include <setjmp.h>
-#include <volser_prototypes.h>
+#include "volser_internal.h"
+#include "volser_prototypes.h"
+#include "vsutils_prototypes.h"
+#include "lockprocs_prototypes.h"
-struct ubik_client *cstruct;
-int verbose = 0;
+extern struct ubik_client *cstruct;
+int verbose = 0, noresolve = 0;
struct release {
- afs_int32 crtime;
- afs_int32 uptime;
+ afs_uint32 crtime;
+ afs_uint32 uptime;
afs_int32 vldbEntryIndex;
};
/* getting rid of this */
-#define ERROR_EXIT(code) {error=(code); goto error_exit;}
+#define ERROR_EXIT(code) do { \
+ error = (code); \
+ goto error_exit; \
+} while (0)
/* Protos for static routines */
+#if 0
static afs_int32 CheckAndDeleteVolume(struct rx_connection *aconn,
- afs_int32 apart, afs_int32 okvol,
- afs_int32 delvol);
-static int DelVol(struct rx_connection *conn, afs_int32 vid, afs_int32 part,
- afs_int32 flags);
+ afs_int32 apart, afs_uint32 okvol,
+ afs_uint32 delvol);
+#endif
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_int32 *origflags, afs_uint32 tmpVolId);
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 int DoVolClone(struct rx_connection *aconn, afs_uint32 avolid,
+ afs_int32 apart, int type, afs_uint32 cloneid,
+ char *typestring, char *pname, char *vname, char *suffix,
+ struct volser_status *volstatus, afs_int32 *transPtr);
+static int DoVolDelete(struct rx_connection *aconn, afs_uint32 avolid,
+ afs_int32 apart, char *typestring, afs_uint32 atoserver,
+ struct volser_status *volstatus, char *pprefix);
+static afs_int32 CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver,
afs_int32 apart, afs_int32 * modentry,
- afs_uint32 * maxvolid);
+ afs_uint32 * maxvolid, struct nvldbentry *aentry);
+static afs_int32 VolumeExists(afs_uint32 server, afs_int32 partition,
+ afs_uint32 volumeid);
+static afs_int32 CheckVldbRWBK(struct nvldbentry * entry,
+ afs_int32 * modified);
+static afs_int32 CheckVldbRO(struct nvldbentry *entry, afs_int32 * modified);
+static afs_int32 CheckVldb(struct nvldbentry *entry, afs_int32 * modified,
+ afs_int32 *deleted);
+static void dump_sig_handler(int x);
+static int sortVolumes(const void *a, const void *b);
/*map the partition <partId> into partition name <partName>*/
}
int
-yesprompt(char *str)
-{
- int response, c;
- int code;
-
- fprintf(STDERR, "Do you want to %s? [yn](n): ", str);
- response = c = getchar();
- while (!(c == EOF || c == '\n'))
- c = getchar(); /*skip to end of line */
- code = (response == 'y' || response == 'Y');
- return code;
-}
-
-
-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_ACFG_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
+AFSVolCreateVolume_retry(struct rx_connection *z_conn,
+ afs_int32 partition, char *name, afs_int32 type,
+ afs_int32 parent, afs_uint32 *volid, afs_int32 *trans)
+{
+ afs_int32 code;
+ int retries = 3;
+ while (retries) {
+ code = AFSVolCreateVolume(z_conn, partition, name, type, parent,
+ volid, trans);
+ if (code != VOLSERVOLBUSY)
+ break;
+ retries--;
+#ifdef AFS_PTHREAD_ENV
+ sleep(3-retries);
+#else
+ IOMGR_Sleep(3-retries);
+#endif
+ }
+ return code;
+}
+
+static int
+AFSVolTransCreate_retry(struct rx_connection *z_conn,
+ afs_int32 volume, afs_int32 partition,
+ afs_int32 flags, afs_int32 * trans)
+{
+ afs_int32 code;
+ int retries = 3;
+ while (retries) {
+ code = AFSVolTransCreate(z_conn, volume, partition, flags, trans);
+ if (code != VOLSERVOLBUSY)
+ break;
+ retries--;
+#ifdef AFS_PTHREAD_ENV
+ sleep(3-retries);
+#else
+ IOMGR_Sleep(3-retries);
+#endif
+ }
+ return code;
+}
+
+#if 0
/* if <okvol> is allright(indicated by beibg able to
* start a transaction, delete the <delvol> */
static afs_int32
CheckAndDeleteVolume(struct rx_connection *aconn, afs_int32 apart,
- afs_int32 okvol, afs_int32 delvol)
+ afs_uint32 okvol, afs_uint32 delvol)
{
afs_int32 error, code, tid, rcode;
-
error = 0;
code = 0;
if (okvol == 0) {
- code = AFSVolTransCreate(aconn, delvol, apart, ITOffline, &tid);
+ code = AFSVolTransCreate_retry(aconn, delvol, apart, ITOffline, &tid);
if (!error && code)
error = code;
code = AFSVolDeleteVolume(aconn, tid);
error = code;
return error;
} else {
- code = AFSVolTransCreate(aconn, okvol, apart, ITOffline, &tid);
+ code = AFSVolTransCreate_retry(aconn, okvol, apart, ITOffline, &tid);
if (!code) {
code = AFSVolEndTrans(aconn, tid, &rcode);
if (!code)
code = rcode;
if (!error && code)
error = code;
- code = AFSVolTransCreate(aconn, delvol, apart, ITOffline, &tid);
+ code = AFSVolTransCreate_retry(aconn, delvol, apart, ITOffline, &tid);
if (!error && code)
error = code;
code = AFSVolDeleteVolume(aconn, tid);
}
}
+#endif
+
/* called by EmuerateEntry, show vldb entry in a reasonable format */
void
SubEnumerateEntry(struct nvldbentry *entry)
int i;
char pname[10];
int isMixed = 0;
+ char hoststr[16];
#ifdef notdef
fprintf(STDOUT, " readWriteID %-10u ", entry->volumeId[RWVOL]);
- if (entry->flags & RW_EXISTS)
+ if (entry->flags & VLF_RWEXISTS)
fprintf(STDOUT, " valid \n");
else
fprintf(STDOUT, " invalid \n");
fprintf(STDOUT, " readOnlyID %-10u ", entry->volumeId[ROVOL]);
- if (entry->flags & RO_EXISTS)
+ if (entry->flags & VLF_ROEXISTS)
fprintf(STDOUT, " valid \n");
else
fprintf(STDOUT, " invalid \n");
fprintf(STDOUT, " backUpID %-10u ", entry->volumeId[BACKVOL]);
- if (entry->flags & BACK_EXISTS)
+ if (entry->flags & VLF_BACKEXISTS)
fprintf(STDOUT, " valid \n");
else
fprintf(STDOUT, " invalid \n");
- if ((entry->cloneId != 0) && (entry->flags & RO_EXISTS))
+ if ((entry->cloneId != 0) && (entry->flags & VLF_ROEXISTS))
fprintf(STDOUT, " releaseClone %-10u \n", entry->cloneId);
#else
- if (entry->flags & RW_EXISTS)
+ if (entry->flags & VLF_RWEXISTS)
fprintf(STDOUT, " RWrite: %-10u", entry->volumeId[RWVOL]);
- if (entry->flags & RO_EXISTS)
+ if (entry->flags & VLF_ROEXISTS)
fprintf(STDOUT, " ROnly: %-10u", entry->volumeId[ROVOL]);
- if (entry->flags & BACK_EXISTS)
+ if (entry->flags & VLF_BACKEXISTS)
fprintf(STDOUT, " Backup: %-10u", entry->volumeId[BACKVOL]);
- if ((entry->cloneId != 0) && (entry->flags & RO_EXISTS))
+ if ((entry->cloneId != 0) && (entry->flags & VLF_ROEXISTS))
fprintf(STDOUT, " RClone: %-10lu", (unsigned long)entry->cloneId);
fprintf(STDOUT, "\n");
#endif
fprintf(STDOUT, " number of sites -> %lu\n",
(unsigned long)entry->nServers);
for (i = 0; i < entry->nServers; i++) {
- if (entry->serverFlags[i] & NEW_REPSITE)
+ if (entry->serverFlags[i] & VLSF_NEWREPSITE)
isMixed = 1;
}
for (i = 0; i < entry->nServers; i++) {
MapPartIdIntoName(entry->serverPartition[i], pname);
fprintf(STDOUT, " server %s partition %s ",
- hostutil_GetNameByINet(entry->serverNumber[i]), pname);
- if (entry->serverFlags[i] & ITSRWVOL)
+ noresolve ? afs_inet_ntoa_r(entry->serverNumber[i], hoststr) :
+ hostutil_GetNameByINet(entry->serverNumber[i]), pname);
+ if (entry->serverFlags[i] & VLSF_RWVOL)
fprintf(STDOUT, "RW Site ");
else
fprintf(STDOUT, "RO Site ");
if (isMixed) {
- if (entry->serverFlags[i] & NEW_REPSITE)
+ if (entry->serverFlags[i] & VLSF_NEWREPSITE)
fprintf(STDOUT," -- New release");
else
- if (!(entry->serverFlags[i] & ITSRWVOL))
+ if (!(entry->serverFlags[i] & VLSF_RWVOL))
fprintf(STDOUT," -- Old release");
} else {
- if (entry->serverFlags[i] & RO_DONTUSE)
+ if (entry->serverFlags[i] & VLSF_DONTUSE)
fprintf(STDOUT, " -- Not released");
}
fprintf(STDOUT, "\n");
/* forcibly remove a volume. Very dangerous call */
int
-UV_NukeVolume(afs_int32 server, afs_int32 partid, afs_int32 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_PartitionInfo(afs_int32 server, char *pname,
- struct diskPartition *partition)
+UV_PartitionInfo64(afs_uint32 server, char *pname,
+ struct diskPartition64 *partition)
{
- register struct rx_connection *aconn;
- afs_int32 code;
+ struct rx_connection *aconn;
+ afs_int32 code = 0;
- code = 0;
- aconn = (struct rx_connection *)0;
aconn = UV_Bind(server, AFSCONF_VOLUMEPORT);
- code = AFSVolPartitionInfo(aconn, pname, partition);
+ code = AFSVolPartitionInfo64(aconn, pname, partition);
+ if (code == RXGEN_OPCODE) {
+ struct diskPartition *dpp = malloc(sizeof(struct diskPartition));
+ code = AFSVolPartitionInfo(aconn, pname, dpp);
+ if (!code) {
+ strncpy(partition->name, dpp->name, 32);
+ strncpy(partition->devName, dpp->devName, 32);
+ partition->lock_fd = dpp->lock_fd;
+ partition->free = dpp->free;
+ 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,
- afs_int32 * anewid)
+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_int32 * anewid)
+ afs_int32 aspare3, afs_int32 aspare4, afs_uint32 * anewid)
{
+ afs_uint32 roid = 0, bkid = 0;
+ return UV_CreateVolume3(aserver, apart, aname, aquota, aspare1, aspare2,
+ aspare3, aspare4, anewid, &roid, &bkid);
+}
- register struct rx_connection *aconn;
+/**
+ * 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;
tid = 0;
- aconn = (struct rx_connection *)0;
error = 0;
+ memset(&storeEntry, 0, sizeof(struct nvldbentry));
+
init_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) {
+ lastid = max(lastid, *aroid);
+ }
+ if (abkid && *abkid != 0) {
+ lastid = max(lastid, *abkid);
+ }
+ if (aroid && *aroid == 0) {
+ *aroid = ++lastid;
+ }
+ if (abkid && *abkid == 0) {
+ *abkid = ++lastid;
+ }
code =
- AFSVolCreateVolume(aconn, apart, aname, volser_RW, 0, anewid, &tid);
- EGOTO2(cfail, vcode, "Failed to create the volume %s %u \n", aname,
+ AFSVolCreateVolume_retry(aconn, apart, aname, volser_RW, 0, anewid, &tid);
+ EGOTO2(cfail, code, "Failed to create the volume %s %u \n", aname,
*anewid);
code = AFSVolSetInfo(aconn, tid, &tstatus);
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.flags = VLF_RWEXISTS; /* this records that rw volume exists */
+ entry.serverFlags[0] = VLSF_RWVOL; /*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 */
rx_DestroyConnection(aconn);
PrintError("", error);
return error;
-
-
}
/* 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,
- afs_int32 aid)
+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 */
+ memset(&storeEntry, 0, sizeof(struct nvldbentry));
+
aconn = (struct rx_connection *)0;
error = 0;
/* 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.flags = VLF_RWEXISTS; /* this records that rw volume exists */
+ entry.serverFlags[0] = VLSF_RWVOL; /*this rep site has rw vol */
entry.volumeId[RWVOL] = aid;
#ifdef notdef
entry.volumeId[ROVOL] = anewid + 1; /* rw,ro, bk id are related in the default case */
}
/* 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_int32 avolid)
+UV_DeleteVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid)
{
struct rx_connection *aconn = (struct rx_connection *)0;
afs_int32 ttid = 0;
afs_int32 avoltype = -1, vtype;
int notondisk = 0, notinvldb = 0;
+ memset(&storeEntry, 0, sizeof(struct nvldbentry));
+
/* Find and read bhe VLDB entry for this volume */
code = ubik_VL_SetLock(cstruct, 0, avolid, avoltype, VLOP_DELETE);
if (code) {
/* Whether volume is in the VLDB or not. Delete the volume on disk */
aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT);
- code = AFSVolTransCreate(aconn, avolid, apart, ITOffline, &ttid);
+
+ code = DoVolDelete(aconn, avolid, apart, "the", 0, NULL, NULL);
if (code) {
- if (code == VNOVOL) {
+ if (code == VNOVOL)
notondisk = 1;
- } else {
- EGOTO1(error_exit, code, "Transaction on volume %u failed\n",
- avolid);
+ else {
+ error = code;
+ goto error_exit;
}
- } else {
- VPRINT1("Trying to delete the volume %u ...", avolid);
-
- code = AFSVolDeleteVolume(aconn, ttid);
- EGOTO1(error_exit, code, "Could not delete the volume %u \n", avolid);
-
- code = AFSVolEndTrans(aconn, ttid, &rcode);
- code = (code ? code : rcode);
- ttid = 0;
- EGOTO1(error_exit, code,
- "Could not end the transaction for the volume %u \n", avolid);
- VDONE;
}
/* Now update the VLDB entry.
/* Its a backup volume, modify the VLDB entry. Check that the
* backup volume is on the server/partition we asked to delete.
*/
- if (!(entry.flags & BACK_EXISTS) || !Lp_Match(aserver, apart, &entry)) {
+ if (!(entry.flags & VLF_BACKEXISTS) || !Lp_Match(aserver, apart, &entry)) {
notinvldb = 2; /* Not on this server and partition */
ERROR_EXIT(0);
}
VPRINT1("Marking the backup volume %u deleted in the VLDB\n", avolid);
- entry.flags &= ~BACK_EXISTS;
+ entry.flags &= ~VLF_BACKEXISTS;
vtype = BACKVOL;
}
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)) {
Lp_SetROValue(&entry, aserver, apart, 0, 0); /* delete the site */
entry.nServers--;
if (!Lp_ROMatch(0, 0, &entry))
- entry.flags &= ~RO_EXISTS; /* This was the last ro volume */
+ entry.flags &= ~VLF_ROEXISTS; /* This was the last ro volume */
vtype = ROVOL;
}
* Check that the readwrite volumes is on the server/partition we
* asked to delete.
*/
- if (!(entry.flags & RW_EXISTS) || !Lp_Match(aserver, apart, &entry)) {
+ if (!(entry.flags & VLF_RWEXISTS) || !Lp_Match(aserver, apart, &entry)) {
notinvldb = 2; /* Not found on this server and partition */
ERROR_EXIT(0);
}
- /* Delete backup if it exists */
- code =
- AFSVolTransCreate(aconn, entry.volumeId[BACKVOL], apart,
- ITOffline, &ttid);
- if (!code) {
- if (verbose) {
- fprintf(STDOUT, "Trying to delete the backup volume %u ...",
- entry.volumeId[BACKVOL]);
- fflush(STDOUT);
+ if (entry.volumeId[BACKVOL]) {
+ /* Delete backup if it exists */
+ code = DoVolDelete(aconn, entry.volumeId[BACKVOL], apart,
+ "the backup", 0, NULL, NULL);
+ if (code && code != VNOVOL) {
+ error = code;
+ goto error_exit;
}
- code = AFSVolDeleteVolume(aconn, ttid);
- EGOTO1(error_exit, code, "Could not delete the volume %u \n",
- entry.volumeId[BACKVOL]);
-
- code = AFSVolEndTrans(aconn, ttid, &rcode);
- ttid = 0;
- code = (code ? code : rcode);
- EGOTO1(error_exit, code,
- "Could not end the transaction for the volume %u \n",
- entry.volumeId[BACKVOL]);
- if (verbose)
- fprintf(STDOUT, " done\n");
}
if (verbose)
"Marking the readwrite volume %lu%s deleted in the VLDB\n",
(unsigned long)avolid,
((entry.
- flags & BACK_EXISTS) ? ", and its backup volume," :
+ flags & VLF_BACKEXISTS) ? ", and its backup volume," :
""));
Lp_SetRWValue(&entry, aserver, apart, 0L, 0L);
entry.nServers--;
- entry.flags &= ~(BACK_EXISTS | RW_EXISTS);
+ entry.flags &= ~(VLF_BACKEXISTS | VLF_RWEXISTS);
vtype = RWVOL;
- if (entry.flags & RO_EXISTS)
+ if (entry.flags & VLF_ROEXISTS)
fprintf(STDERR, "WARNING: ReadOnly copy(s) may still exist\n");
}
}
/* Either delete or replace the VLDB entry */
- if ((entry.nServers <= 0) || !(entry.flags & (RO_EXISTS | RW_EXISTS))) {
+ if ((entry.nServers <= 0) || !(entry.flags & (VLF_ROEXISTS | VLF_RWEXISTS))) {
if (verbose)
fprintf(STDOUT,
"Last reference to the VLDB entry for %lu - deleting entry\n",
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;
+ return NULL;
+}
+
+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);
+}
- return;
+static int
+DoVolDelete(struct rx_connection *aconn, afs_uint32 avolid,
+ afs_int32 apart, char *ptypestring, afs_uint32 atoserver,
+ struct volser_status *volstatus, char *pprefix)
+{
+ afs_int32 ttid = 0, code, rcode, error = 0;
+ char *prefix, *typestring;
+ int beverbose = 0;
+
+ if (pprefix)
+ prefix = pprefix;
+ else
+ prefix = "";
+
+ if (ptypestring) {
+ typestring = ptypestring;
+ beverbose = 1;
+ } else
+ typestring = "the";
+
+ if (beverbose)
+ VPRINT3("%sDeleting %s volume %u ...", prefix, typestring, avolid);
+
+ code =
+ AFSVolTransCreate_retry(aconn, avolid, apart, ITOffline, &ttid);
+
+ /* return early and quietly for VNOVOL; don't continue the attempt to delete. */
+ if (code == VNOVOL) {
+ error = code;
+ goto dfail;
+ }
+
+ EGOTO2(dfail, code, "%sFailed to start transaction on %u\n",
+ prefix, avolid);
+
+ if (volstatus) {
+ code = AFSVolGetStatus(aconn, ttid, volstatus);
+ EGOTO2(dfail, code, "%sCould not get timestamp from volume %u\n",
+ prefix, avolid);
+ }
+
+ code =
+ AFSVolSetFlags(aconn, ttid,
+ VTDeleteOnSalvage | VTOutOfService);
+
+ EGOTO2(dfail, code, "%sCould not set flags on volume %u \n",
+ prefix, avolid);
+
+ if (atoserver) {
+ VPRINT1("%sSetting volume forwarding pointer ...", prefix);
+ AFSVolSetForwarding(aconn, ttid, atoserver);
+ VDONE;
+ }
+
+ code = AFSVolDeleteVolume(aconn, ttid);
+ EGOTO2(dfail, code, "%sCould not delete volume %u\n", prefix, avolid);
+
+dfail:
+ if (ttid) {
+ code = AFSVolEndTrans(aconn, ttid, &rcode);
+ ttid = 0;
+ if (!code)
+ code = rcode;
+ if (code) {
+ fprintf(STDERR, "%sCould not end transaction on %s volume %lu \n",
+ prefix, typestring, (unsigned long)avolid);
+ if (!error)
+ error = code;
+ }
+ }
+
+ if (beverbose && !error)
+ VDONE;
+ return error;
+}
+
+static int
+DoVolClone(struct rx_connection *aconn, afs_uint32 avolid,
+ afs_int32 apart, int type, afs_uint32 cloneid,
+ char *typestring, char *pname, char *vname, char *suffix,
+ struct volser_status *volstatus, afs_int32 *transPtr)
+{
+ char cname[64];
+ afs_int32 ttid = 0, btid = 0;
+ afs_int32 code = 0, rcode = 0;
+ afs_int32 error = 0;
+ int cloneexists = 1;
+
+ /* Test to see if the clone volume exists by trying to create
+ * a transaction on the clone volume. We've assumed the clone exists.
+ */
+ code = AFSVolTransCreate_retry(aconn, cloneid, apart, ITOffline, &btid);
+ if (code) {
+ if (code != VNOVOL) {
+ EPRINT2(code, "Could not reach the %s volume %lu\n",
+ typestring, (unsigned long)cloneid);
+ error = code;
+ goto cfail;
+ }
+ cloneexists = 0; /* clone volume does not exist */
+ }
+ if (btid) {
+ code = AFSVolEndTrans(aconn, btid, &rcode);
+ btid = 0;
+ if (code || rcode) {
+ fprintf(STDERR,
+ "Could not end transaction on the previous %s volume %lu\n",
+ typestring, (unsigned long)cloneid);
+ error = (code ? code : rcode);
+ goto cfail;
+ }
+ }
+
+ /* Now go ahead and try to clone the RW volume.
+ * First start a transaction on the RW volume
+ */
+ code = AFSVolTransCreate_retry(aconn, avolid, apart, ITBusy, &ttid);
+ if (code) {
+ fprintf(STDERR, "Could not start a transaction on the volume %lu\n",
+ (unsigned long)avolid);
+ error = code;
+ goto cfail;
+ }
+
+ /* Clone or reclone the volume, depending on whether the clone
+ * volume exists or not
+ */
+ if (cloneexists) {
+ VPRINT2("Re-cloning %s volume %u ...", typestring, cloneid);
+
+ code = AFSVolReClone(aconn, ttid, cloneid);
+ if (code) {
+ EPRINT2(code, "Could not re-clone %s volume %lu\n",
+ typestring, (unsigned long)cloneid);
+ error = code;
+ goto cfail;
+ }
+ } else {
+ VPRINT2("Creating a new %s clone %u ...", typestring, cloneid);
+
+ if (!vname) {
+ strcpy(cname, pname);
+ strcat(cname, suffix);
+ }
+
+ code = AFSVolClone(aconn, ttid, 0, type, vname?vname:cname,
+ &cloneid);
+ if (code) {
+ fprintf(STDERR, "Failed to clone the volume %lu\n",
+ (unsigned long)avolid);
+ error = code;
+ goto cfail;
+ }
+ }
+
+ VDONE;
+
+ if (volstatus) {
+ VPRINT1("Getting status of parent volume %u...", avolid);
+ code = AFSVolGetStatus(aconn, ttid, volstatus);
+ if (code) {
+ fprintf(STDERR, "Failed to get the status of the parent volume %lu\n",
+ (unsigned long)avolid);
+ error = code;
+ goto cfail;
+ }
+ VDONE;
+ }
+
+cfail:
+ if (ttid) {
+ code = AFSVolEndTrans(aconn, ttid, &rcode);
+ if (code || rcode) {
+ fprintf(STDERR, "Could not end transaction on the volume %lu\n",
+ (unsigned long)avolid);
+ if (!error)
+ error = (code ? code : rcode);
+ }
+ }
+
+ if (btid) {
+ code = AFSVolEndTrans(aconn, btid, &rcode);
+ if (code || rcode) {
+ fprintf(STDERR,
+ "Could not end transaction on the %s volume %lu\n",
+ typestring, (unsigned long)cloneid);
+ if (!error)
+ error = (code ? code : rcode);
+ }
+ }
+ return error;
}
+/* Convert volume from RO to RW; adjust the VLDB entry to match.
+ * The nvldbentry passed to us has already been MapHostToNetwork'd
+ * by the caller.
+ */
+
+int
+UV_ConvertRO(afs_uint32 server, afs_uint32 partition, afs_uint32 volid,
+ struct nvldbentry *entry)
+{
+ afs_int32 code, i, same;
+ struct nvldbentry checkEntry, storeEntry;
+ afs_int32 vcode;
+ afs_int32 rwindex = 0;
+ afs_uint32 rwserver = 0;
+ afs_int32 roindex = 0;
+ afs_uint32 roserver = 0;
+ struct rx_connection *aconn;
+
+ memset(&storeEntry, 0, sizeof(struct nvldbentry));
+
+ vcode =
+ ubik_VL_SetLock(cstruct, 0, entry->volumeId[RWVOL], RWVOL,
+ VLOP_MOVE);
+ if (vcode) {
+ fprintf(STDERR,
+ "Unable to lock volume %lu, code %d\n",
+ (unsigned long)entry->volumeId[RWVOL],vcode);
+ PrintError("", vcode);
+ return -1;
+ }
+
+ /* make sure the VLDB entry hasn't changed since we started */
+ memset(&checkEntry, 0, sizeof(checkEntry));
+ vcode = VLDB_GetEntryByID(volid, -1, &checkEntry);
+ if (vcode) {
+ fprintf(STDERR,
+ "Could not fetch the entry for volume %lu from VLDB\n",
+ (unsigned long)volid);
+ PrintError("convertROtoRW ", vcode);
+ code = vcode;
+ goto error_exit;
+ }
+
+ MapHostToNetwork(&checkEntry);
+ entry->flags &= ~VLOP_ALLOPERS; /* clear any stale lock operation flags */
+ entry->flags |= VLOP_MOVE; /* set to match SetLock operation above */
+ if (memcmp(entry, &checkEntry, sizeof(*entry)) != 0) {
+ fprintf(STDERR,
+ "VLDB entry for volume %lu has changed; please reissue the command.\n",
+ (unsigned long)volid);
+ code = -1;
+ goto error_exit;
+ }
+
+ /* extract information from the original entry */
+ for (i = 0; i < entry->nServers; i++) {
+ if (entry->serverFlags[i] & VLSF_RWVOL) {
+ rwindex = i;
+ rwserver = entry->serverNumber[i];
+ /* rwpartition = entry->serverPartition[i]; */
+ if (roserver)
+ break;
+ } else if ((entry->serverFlags[i] & VLSF_ROVOL) && !roserver) {
+ same = VLDB_IsSameAddrs(server, entry->serverNumber[i], &code);
+ if (code) {
+ fprintf(STDERR,
+ "Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n",
+ server, code);
+ code = ENOENT;
+ goto error_exit;
+ }
+ if (same) {
+ roindex = i;
+ roserver = entry->serverNumber[i];
+ /* ropartition = entry->serverPartition[i]; */
+ if (rwserver)
+ break;
+ }
+ }
+ }
+
+ aconn = UV_Bind(server, AFSCONF_VOLUMEPORT);
+ code = AFSVolConvertROtoRWvolume(aconn, partition, volid);
+ if (code) {
+ fprintf(STDERR,
+ "Converting RO volume %lu to RW volume failed with code %d\n",
+ (unsigned long)volid, code);
+ PrintError("convertROtoRW ", code);
+ goto error_exit;
+ }
+ /* Update the VLDB to match what we did on disk as much as possible. */
+ /* If the converted RO was in the VLDB, make it look like the new RW. */
+ if (roserver) {
+ entry->serverFlags[roindex] = VLSF_RWVOL;
+ } else {
+ /* Add a new site entry for the newly created RW. It's possible
+ * (but unlikely) that we are already at MAXNSERVERS and that this
+ * new site will invalidate the whole VLDB entry; however,
+ * VLDB_ReplaceEntry will detect this and return VL_BADSERVER,
+ * so we need no extra guard logic here.
+ */
+ afs_int32 newrwindex = entry->nServers;
+ (entry->nServers)++;
+ entry->serverNumber[newrwindex] = server;
+ entry->serverPartition[newrwindex] = partition;
+ entry->serverFlags[newrwindex] = VLSF_RWVOL;
+ }
+ entry->flags |= VLF_RWEXISTS;
+ entry->flags &= ~VLF_BACKEXISTS;
+
+ /* if the old RW was in the VLDB, remove it by decrementing the number */
+ /* of servers, replacing the RW entry with the last entry, and zeroing */
+ /* out the last entry. */
+ if (rwserver) {
+ (entry->nServers)--;
+ if (rwindex != entry->nServers) {
+ entry->serverNumber[rwindex] = entry->serverNumber[entry->nServers];
+ entry->serverPartition[rwindex] =
+ entry->serverPartition[entry->nServers];
+ entry->serverFlags[rwindex] = entry->serverFlags[entry->nServers];
+ entry->serverNumber[entry->nServers] = 0;
+ entry->serverPartition[entry->nServers] = 0;
+ entry->serverFlags[entry->nServers] = 0;
+ }
+ }
+ entry->flags &= ~VLF_ROEXISTS;
+ for (i = 0; i < entry->nServers; i++) {
+ if (entry->serverFlags[i] & VLSF_ROVOL) {
+ if (!(entry->serverFlags[i] & (VLSF_DONTUSE | VLSF_NEWREPSITE)))
+ entry->flags |= VLF_ROEXISTS;
+ }
+ }
+ MapNetworkToHost(entry, &storeEntry);
+ code =
+ VLDB_ReplaceEntry(entry->volumeId[RWVOL], RWVOL, &storeEntry,
+ (LOCKREL_OPCODE | LOCKREL_AFSID |
+ LOCKREL_TIMESTAMP));
+ if (code) {
+ fprintf(STDERR,
+ "Warning: volume converted, but vldb update failed with code %d!\n",
+ code);
+ }
+
+ error_exit:
+ vcode = UV_LockRelease(entry->volumeId[RWVOL]);
+ if (vcode) {
+ fprintf(STDERR,
+ "Unable to unlock volume %lu, code %d\n",
+ (unsigned long)entry->volumeId[RWVOL],vcode);
+ PrintError("", vcode);
+ }
+ return code;
+}
+
+
/* 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_int32 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_int32 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;
+ char hoststr[16];
#ifdef ENABLE_BUGFIX_1165
volEntries volumeInfo;
fprintf(STDOUT, "First test point - operation not started.\n");
fprintf(STDOUT, "...test here (y, n)? ");
fflush(STDOUT);
- fscanf(stdin, "%c", &in);
- fscanf(stdin, "%c", &lf); /* toss away */
+ if (fscanf(stdin, "%c", &in) < 1)
+ in = 0;
+ if (fscanf(stdin, "%c", &lf) < 0) /* toss away */
+ ; /* don't care */
if (in == 'y') {
fprintf(STDOUT, "type control-c\n");
while (1) {
(unsigned long)afromvol);
fprintf(STDERR, "The current site is :");
for (i = 0; i < entry.nServers; i++) {
- if (entry.serverFlags[i] == ITSRWVOL) {
+ if (entry.serverFlags[i] == VLSF_RWVOL) {
char pname[10];
MapPartIdIntoName(entry.serverPartition[i], pname);
fprintf(STDERR, " server %s partition %s \n",
- hostutil_GetNameByINet(entry.serverNumber[i]),
+ noresolve ? afs_inet_ntoa_r(entry.serverNumber[i], hoststr) :
+ hostutil_GetNameByINet(entry.serverNumber[i]),
pname);
}
}
* may still be existing physically on from fileserver
*/
fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT);
- fromtid = 0;
pntg = 1;
- code =
- AFSVolTransCreate(fromconn, afromvol, afrompart, ITOffline,
- &fromtid);
- if (!code) { /* volume exists - delete it */
- VPRINT1("Setting flags on leftover source volume %u ...",
- afromvol);
- code =
- AFSVolSetFlags(fromconn, fromtid,
- VTDeleteOnSalvage | VTOutOfService);
- EGOTO1(mfail, code,
- "Failed to set flags on the leftover source volume %u\n",
- afromvol);
- VDONE;
-
- VPRINT1("Deleting leftover source volume %u ...", afromvol);
- code = AFSVolDeleteVolume(fromconn, fromtid);
- EGOTO1(mfail, code,
- "Failed to delete the leftover source volume %u\n",
- afromvol);
- VDONE;
-
- VPRINT1("Ending transaction on leftover source volume %u ...",
- afromvol);
- code = AFSVolEndTrans(fromconn, fromtid, &rcode);
- fromtid = 0;
- if (!code)
- code = rcode;
- EGOTO1(mfail, code,
- "Could not end the transaction for the leftover source volume %u \n",
- afromvol);
- VDONE;
+ code = DoVolDelete(fromconn, afromvol, afrompart,
+ "leftover", 0, NULL, NULL);
+ if (code && code != VNOVOL) {
+ error = code;
+ goto mfail;
}
- /*delete the backup volume now */
- fromtid = 0;
- code =
- AFSVolTransCreate(fromconn, backupId, afrompart, ITOffline,
- &fromtid);
- if (!code) { /* backup volume exists - delete it */
- VPRINT1("Setting flags on leftover backup volume %u ...",
- backupId);
- code =
- AFSVolSetFlags(fromconn, fromtid,
- VTDeleteOnSalvage | VTOutOfService);
- EGOTO1(mfail, code,
- "Failed to set flags on the backup volume %u\n", backupId);
- VDONE;
-
- VPRINT1("Deleting leftover backup volume %u ...", backupId);
- code = AFSVolDeleteVolume(fromconn, fromtid);
- EGOTO1(mfail, code,
- "Could not delete the leftover backup volume %u\n",
- backupId);
- VDONE;
-
- VPRINT1("Ending transaction on leftover backup volume %u ...",
- backupId);
- code = AFSVolEndTrans(fromconn, fromtid, &rcode);
- fromtid = 0;
- if (!code)
- code = rcode;
- EGOTO1(mfail, code,
- "Could not end the transaction for the leftover backup volume %u\n",
- backupId);
- VDONE;
+ code = DoVolDelete(fromconn, backupId, afrompart,
+ "leftover backup", 0, NULL, NULL);
+ if (code && code != VNOVOL) {
+ error = code;
+ goto mfail;
}
fromtid = 0;
}
/* 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);
pntg = 1;
toconn = UV_Bind(atoserver, AFSCONF_VOLUMEPORT); /* get connections to the servers */
fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT);
- fromtid = totid = 0; /* initialize to uncreated */
+ totid = 0; /* initialize to uncreated */
/* ***
* clone the read/write volume locally.
* ***/
VPRINT1("Starting transaction on source volume %u ...", afromvol);
- code = AFSVolTransCreate(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);
+ 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(fromconn, newVol, afrompart, ITOffline,
- &clonetid);
+ AFSVolTransCreate_retry(fromconn, newVol, afrompart, ITOffline,
+ &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(toconn, volid, atopart, ITOffline, &totid);
- if (!code) {
- /* Delete the existing volume.
- * While we are deleting the volume in these steps, the transaction
- * we started against the cloned volume (clonetid above) will be
- * sitting idle. It will get cleaned up after 600 seconds
- */
- VPRINT1("Deleting pre-existing volume %u on destination ...", volid);
- code = AFSVolDeleteVolume(toconn, totid);
- EGOTO1(mfail, code,
- "Could not delete the pre-existing volume %u on destination\n",
- volid);
- VDONE;
-
- VPRINT1
- ("Ending transaction on pre-existing volume %u on destination ...",
- volid);
- code = AFSVolEndTrans(toconn, totid, &rcode);
- totid = 0;
- if (!code)
- code = rcode;
- EGOTO1(mfail, code,
- "Could not end the transaction on pre-existing volume %u on destination\n",
- volid);
- VDONE;
+ code = DoVolDelete(toconn, volid, atopart,
+ "pre-existing destination", 0, NULL, NULL);
+ if (code && code != VNOVOL) {
+ error = code;
+ goto mfail;
}
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(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);
Lp_SetRWValue(&entry, afromserver, afrompart, atoserver, atopart);
MapNetworkToHost(&entry, &storeEntry);
- storeEntry.flags &= ~BACK_EXISTS;
+ storeEntry.flags &= ~VLF_BACKEXISTS;
if (TESTC) {
fprintf(STDOUT,
"Second test point - operation in progress but not complete.\n");
fprintf(STDOUT, "...test here (y, n)? ");
fflush(STDOUT);
- fscanf(stdin, "%c", &in);
- fscanf(stdin, "%c", &lf); /* toss away */
+ if (fscanf(stdin, "%c", &in) < 1)
+ in = 0;
+ if (fscanf(stdin, "%c", &lf) < 0) /* toss away */
+ ; /* don't care */
if (in == 'y') {
fprintf(STDOUT, "type control-c\n");
while (1) {
"Third test point - operation complete but no cleanup.\n");
fprintf(STDOUT, "...test here (y, n)? ");
fflush(STDOUT);
- fscanf(stdin, "%c", &in);
- fscanf(stdin, "%c", &lf); /* toss away */
+ if (fscanf(stdin, "%c", &in) < 1)
+ in = 0;
+ if (fscanf(stdin, "%c", &lf) < 0) /* toss away */
+ ; /* don't care */
if (in == 'y') {
fprintf(STDOUT, "type control-c\n");
while (1) {
afromvol);
VDONE;
- /* Delete the backup volume on the original site */
- VPRINT1("Creating transaction for backup volume %u on source ...",
- backupId);
- code =
- AFSVolTransCreate(fromconn, backupId, afrompart, ITOffline, &fromtid);
- VDONE;
- if (!code) {
- VPRINT1("Setting flags on backup volume %u on source ...", backupId);
- code =
- AFSVolSetFlags(fromconn, fromtid,
- VTDeleteOnSalvage | VTOutOfService);
- EGOTO1(mfail, code,
- "Failed to set the flags on the backup volume %u on the source\n",
- backupId);
- VDONE;
+ code = DoVolDelete(fromconn, backupId, afrompart,
+ "source backup", 0, NULL, NULL);
+ if (code && code != VNOVOL) {
+ error = code;
+ goto mfail;
+ }
- VPRINT1("Deleting the backup volume %u on the source ...", backupId);
- code = AFSVolDeleteVolume(fromconn, fromtid);
- EGOTO1(mfail, code,
- "Failed to delete the backup volume %u on the source\n",
- backupId);
- VDONE;
-
- VPRINT1("Ending transaction on backup volume %u on source ...",
- backupId);
- code = AFSVolEndTrans(fromconn, fromtid, &rcode);
- fromtid = 0;
- if (!code)
- code = rcode;
- EGOTO1(mfail, code,
- "Failed to end the transaction on the backup volume %u on the source\n",
- backupId);
- VDONE;
- } else
- code = 0; /* no backup volume? that's okay */
+ code = 0; /* no backup volume? that's okay */
fromtid = 0;
if (!(flags & RV_NOCLONE)) {
- VPRINT1("Starting transaction on the cloned volume %u ...", newVol);
- code =
- AFSVolTransCreate(fromconn, newVol, afrompart, ITOffline,
- &clonetid);
- EGOTO1(mfail, code,
- "Failed to start a transaction on the cloned volume%u\n",
- newVol);
- VDONE;
-
- /* now delete the clone */
- VPRINT1("Deleting the cloned volume %u ...", newVol);
- code = AFSVolDeleteVolume(fromconn, clonetid);
- EGOTO1(mfail, code, "Failed to delete the cloned volume %u\n",
- newVol);
- VDONE;
-
- VPRINT1("Ending transaction on cloned volume %u ...", newVol);
- code = AFSVolEndTrans(fromconn, clonetid, &rcode);
- if (!code)
- code = rcode;
- clonetid = 0;
- EGOTO1(mfail, code,
- "Failed to end the transaction on the cloned volume %u\n",
- newVol);
- VDONE;
+ code = DoVolDelete(fromconn, newVol, afrompart,
+ "cloned", 0, NULL, NULL);
+ if (code) {
+ if (code == VNOVOL) {
+ EPRINT1(code, "Failed to start transaction on %u\n", newVol);
+ }
+ error = code;
+ goto mfail;
+ }
}
/* fall through */
fprintf(STDOUT, "Fourth test point - operation complete.\n");
fprintf(STDOUT, "...test here (y, n)? ");
fflush(STDOUT);
- fscanf(stdin, "%c", &in);
- fscanf(stdin, "%c", &lf); /* toss away */
+ if (fscanf(stdin, "%c", &in) < 1)
+ in = 0;
+ if (fscanf(stdin, "%c", &lf) < 0) /* toss away */
+ ; /* don't care */
if (in == 'y') {
fprintf(STDOUT, "type control-c\n");
while (1) {
/* normal cleanup code */
- if (entry.flags & RO_EXISTS)
+ if (entry.flags & VLF_ROEXISTS)
fprintf(STDERR, "WARNING : readOnly copies still exist \n");
if (islocked) {
ubik_VL_ReleaseLock(cstruct, 0, afromvol, -1,
(LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
VDONE;
+ islocked = 0;
}
if (clonetid) {
}
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 */
}
if (volid && toconn) {
- VPRINT1
- ("Recovery: Creating transaction for destination volume %u ...",
- volid);
- code =
- AFSVolTransCreate(toconn, volid, atopart, ITOffline, &totid);
-
- if (!code) {
- VDONE;
-
- VPRINT1
- ("Recovery: Setting flags on destination volume %u ...",
- volid);
- AFSVolSetFlags(toconn, totid,
- VTDeleteOnSalvage | VTOutOfService);
- VDONE;
-
- VPRINT1("Recovery: Deleting destination volume %u ...",
- volid);
- AFSVolDeleteVolume(toconn, totid);
- VDONE;
-
- VPRINT1
- ("Recovery: Ending transaction on destination volume %u ...",
- volid);
- AFSVolEndTrans(toconn, totid, &rcode);
- VDONE;
- } else {
- VPRINT1
- ("\nRecovery: Unable to start transaction on destination volume %u.\n",
- afromvol);
+ code = DoVolDelete(toconn, volid, atopart,
+ "destination", 0, NULL, "Recovery:");
+ if (code == VNOVOL) {
+ EPRINT1(code, "Recovery: Failed to start transaction on %u\n", volid);
}
- }
+ }
/* put source volume on-line */
if (fromconn) {
VPRINT1("Recovery: Creating transaction on source volume %u ...",
afromvol);
+ tmp = fromtid;
code =
- AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy,
- &fromtid);
+ AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy,
+ &tmp);
+ fromtid = tmp;
if (!code) {
VDONE;
/* delete backup volume */
if (fromconn) {
- VPRINT1("Recovery: Creating transaction on backup volume %u ...",
- backupId);
- code =
- AFSVolTransCreate(fromconn, backupId, afrompart, ITOffline,
- &fromtid);
- if (!code) {
- VDONE;
-
- VPRINT1("Recovery: Setting flags on backup volume %u ...",
- backupId);
- AFSVolSetFlags(fromconn, fromtid,
- VTDeleteOnSalvage | VTOutOfService);
- VDONE;
-
- VPRINT1("Recovery: Deleting backup volume %u ...", backupId);
- AFSVolDeleteVolume(fromconn, fromtid);
- VDONE;
-
- VPRINT1
- ("Recovery: Ending transaction on backup volume %u ...",
- backupId);
- AFSVolEndTrans(fromconn, fromtid, &rcode);
- VDONE;
- } else {
- VPRINT1
- ("\nRecovery: Unable to start transaction on backup volume %u.\n",
- backupId);
+ code = DoVolDelete(fromconn, backupId, afrompart,
+ "backup", 0, NULL, "Recovery:");
+ if (code == VNOVOL) {
+ EPRINT1(code, "Recovery: Failed to start transaction on %u\n", backupId);
}
- /* delete source volume */
- VPRINT1("Recovery: Creating transaction on source volume %u ...",
- afromvol);
- code =
- AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy,
- &fromtid);
- if (!code) {
- VDONE;
-
- VPRINT1("Recovery: Setting flags on backup volume %u ...",
- afromvol);
- AFSVolSetFlags(fromconn, fromtid,
- VTDeleteOnSalvage | VTOutOfService);
- VDONE;
-
- if (atoserver != afromserver) {
- VPRINT("Recovery: Setting volume forwarding pointer ...");
- AFSVolSetForwarding(fromconn, fromtid, atoserver);
- VDONE;
- }
-
- VPRINT1("Recovery: Deleting source volume %u ...", afromvol);
- AFSVolDeleteVolume(fromconn, fromtid);
- VDONE;
-
- VPRINT1
- ("Recovery: Ending transaction on source volume %u ...",
- afromvol);
- AFSVolEndTrans(fromconn, fromtid, &rcode);
- VDONE;
- } else {
- VPRINT1
- ("\nRecovery: Unable to start transaction on source volume %u.\n",
- afromvol);
+ code = DoVolDelete(fromconn, afromvol, afrompart, "source",
+ (atoserver != afromserver)?atoserver:0,
+ NULL, NULL);
+ if (code == VNOVOL) {
+ EPRINT1(code, "Failed to start transaction on %u\n", afromvol);
}
}
}
/* common cleanup - delete local clone */
- if (newVol) {
- VPRINT1("Recovery: Creating transaction on clone volume %u ...",
- newVol);
- code =
- AFSVolTransCreate(fromconn, newVol, afrompart, ITOffline,
- &clonetid);
- if (!code) {
- VDONE;
-
- VPRINT1("Recovery: Deleting clone volume %u ...", newVol);
- AFSVolDeleteVolume(fromconn, clonetid);
- VDONE;
-
- VPRINT1("Recovery: Ending transaction on clone volume %u ...",
- newVol);
- AFSVolEndTrans(fromconn, clonetid, &rcode);
- VDONE;
- } else {
- VPRINT1
- ("\nRecovery: Unable to start transaction on source volume %u.\n",
- afromvol);
+ if (newVol) {
+ code = DoVolDelete(fromconn, newVol, afrompart,
+ "clone", 0, NULL, "Recovery:");
+ if (code == VNOVOL) {
+ EPRINT1(code, "Recovery: Failed to start transaction on %u\n", newVol);
}
}
/* unlock VLDB entry */
- VPRINT1("Recovery: Releasing lock on VLDB entry for volume %u ...",
- afromvol);
- ubik_VL_ReleaseLock(cstruct, 0, afromvol, -1,
- (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
- VDONE;
-
+ if (islocked) {
+ VPRINT1("Recovery: Releasing lock on VLDB entry for volume %u ...",
+ afromvol);
+ ubik_VL_ReleaseLock(cstruct, 0, afromvol, -1,
+ (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
+ VDONE;
+ }
done: /* routine cleanup */
if (volName)
free(volName);
int
-UV_MoveVolume(afs_int32 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_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
- char *atovolname, afs_int32 atoserver, afs_int32 atopart,
- afs_int32 atovolid, int flags)
+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_int32 cloneVol, newVol, volflag;
+ 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);
- code = AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy,
- &fromtid);
+ tmp = 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;
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(fromconn, cloneVol, afrompart, ITOffline,
- &clonetid);
+ AFSVolTransCreate_retry(fromconn, cloneVol, afrompart, ITOffline,
+ &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(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(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);
&cookie);
EGOTO1(mfail, code,
"Failed to do the%s dump from old site to new site\n",
- afromvol);
+ (flags & RV_NOCLONE) ? "" : " incremental");
VDONE;
VPRINT1("Setting volume flags on destination volume %u ...", newVol);
fromtid = 0;
if (!(flags & RV_NOCLONE)) {
- VPRINT1("Starting transaction on the cloned volume %u ...", cloneVol);
- code =
- AFSVolTransCreate(fromconn, cloneVol, afrompart, ITOffline,
- &clonetid);
- EGOTO1(mfail, code,
- "Failed to start a transaction on the cloned volume%u\n",
- cloneVol);
- VDONE;
-
- /* now delete the clone */
- VPRINT1("Deleting the cloned volume %u ...", cloneVol);
- code = AFSVolDeleteVolume(fromconn, clonetid);
- EGOTO1(mfail, code, "Failed to delete the cloned volume %u\n",
- cloneVol);
- VDONE;
-
- VPRINT1("Ending transaction on cloned volume %u ...", cloneVol);
- code = AFSVolEndTrans(fromconn, clonetid, &rcode);
- if (!code)
- code = rcode;
- clonetid = 0;
- EGOTO1(mfail, code,
- "Failed to end the transaction on the cloned volume %u\n",
- cloneVol);
- VDONE;
+ code = DoVolDelete(fromconn, cloneVol, afrompart,
+ "cloned", 0, NULL, NULL);
+ if (code) {
+ if (code == VNOVOL) {
+ EPRINT1(code, "Failed to start transaction on %u\n", cloneVol);
+ }
+ error = code;
+ goto mfail;
+ }
}
if (!(flags & RV_NOVLDB)) {
newentry.nServers = 1;
newentry.serverNumber[0] = atoserver;
newentry.serverPartition[0] = atopart;
- newentry.flags = (flags & RV_RDONLY) ? RO_EXISTS : RW_EXISTS;
- newentry.serverFlags[0] = (flags & RV_RDONLY) ? ITSROVOL : ITSRWVOL;
+ newentry.flags = (flags & RV_RDONLY) ? VLF_ROEXISTS : VLF_RWEXISTS;
+ newentry.serverFlags[0] = (flags & RV_RDONLY) ? VLSF_ROVOL : VLSF_RWVOL;
newentry.volumeId[RWVOL] = newVol;
newentry.volumeId[ROVOL] = (flags & RV_RDONLY) ? newVol : 0;
newentry.volumeId[BACKVOL] = 0;
/* common cleanup - delete local clone */
if (cloneVol) {
- VPRINT1("Recovery: Creating transaction on clone volume %u ...",
- cloneVol);
- code =
- AFSVolTransCreate(fromconn, cloneVol, afrompart, ITOffline,
- &clonetid);
- if (!code) {
- VDONE;
-
- VPRINT1("Recovery: Deleting clone volume %u ...", cloneVol);
- AFSVolDeleteVolume(fromconn, clonetid);
- VDONE;
-
- VPRINT1("Recovery: Ending transaction on clone volume %u ...",
- cloneVol);
- AFSVolEndTrans(fromconn, clonetid, &rcode);
- VDONE;
- } else {
- VPRINT1
- ("\nRecovery: Unable to start transaction on clone volume %u.\n",
- cloneVol);
+ code = DoVolDelete(fromconn, cloneVol, afrompart,
+ "clone", 0, NULL, "Recovery:");
+ if (code == VNOVOL) {
+ EPRINT1(code, "Recovery: Failed to start transaction on %u\n", cloneVol);
}
}
int
-UV_CopyVolume(afs_int32 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_int32 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;
- afs_int32 backupID;
+ afs_uint32 backupID;
afs_int32 code = 0, rcode = 0;
- char vname[VOLSER_MAXVOLNAME + 1];
struct nvldbentry entry, storeEntry;
afs_int32 error = 0;
- int vldblocked = 0, vldbmod = 0, backexists = 1;
+ int vldblocked = 0, vldbmod = 0;
aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT);
/* These operations require the VLDB be locked since it means the VLDB
* will change or the vldb is already locked.
*/
- if (!(entry.flags & BACK_EXISTS) || /* backup volume doesnt exist */
+ if (!(entry.flags & VLF_BACKEXISTS) || /* backup volume doesnt exist */
(entry.flags & VLOP_ALLOPERS) || /* vldb lock already held */
(entry.volumeId[BACKVOL] == INVALID_BID)) { /* no assigned backup volume id */
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) {
vldbmod = 1;
}
- /* Test to see if the backup volume exists by trying to create
- * a transaction on the backup volume. We've assumed the backup exists.
- */
- code = AFSVolTransCreate(aconn, backupID, apart, ITOffline, &btid);
- if (code) {
- if (code != VNOVOL) {
- fprintf(STDERR, "Could not reach the backup volume %lu\n",
- (unsigned long)backupID);
- error = code;
- goto bfail;
- }
- backexists = 0; /* backup volume does not exist */
- }
- if (btid) {
- code = AFSVolEndTrans(aconn, btid, &rcode);
- btid = 0;
- if (code || rcode) {
- fprintf(STDERR,
- "Could not end transaction on the previous backup volume %lu\n",
- (unsigned long)backupID);
- error = (code ? code : rcode);
- goto bfail;
- }
- }
-
- /* Now go ahead and try to clone the RW volume.
- * First start a transaction on the RW volume
- */
- code = AFSVolTransCreate(aconn, avolid, apart, ITBusy, &ttid);
+ code = DoVolClone(aconn, avolid, apart, backupVolume, backupID, "backup",
+ entry.name, NULL, ".backup", NULL, NULL);
if (code) {
- fprintf(STDERR, "Could not start a transaction on the volume %lu\n",
- (unsigned long)avolid);
error = code;
goto bfail;
}
- /* Clone or reclone the volume, depending on whether the backup
- * volume exists or not
- */
- if (backexists) {
- VPRINT1("Re-cloning backup volume %u ...", backupID);
-
- code = AFSVolReClone(aconn, ttid, backupID);
- if (code) {
- fprintf(STDERR, "Could not re-clone backup volume %lu\n",
- (unsigned long)backupID);
- error = code;
- goto bfail;
- }
- } else {
- VPRINT1("Creating a new backup clone %u ...", backupID);
-
- strcpy(vname, entry.name);
- strcat(vname, ".backup");
-
- code = AFSVolClone(aconn, ttid, 0, backupVolume, vname, &backupID);
- if (code) {
- fprintf(STDERR, "Failed to clone the volume %lu\n",
- (unsigned long)avolid);
- error = code;
- goto bfail;
- }
- }
-
- /* End the transaction on the RW volume */
- code = AFSVolEndTrans(aconn, ttid, &rcode);
- ttid = 0;
- if (code || rcode) {
- fprintf(STDERR,
- "Failed to end the transaction on the rw volume %lu\n",
- (unsigned long)avolid);
- error = (code ? code : rcode);
- goto bfail;
- }
-
- /* Mork vldb as backup exists */
- if (!(entry.flags & BACK_EXISTS)) {
- entry.flags |= BACK_EXISTS;
+ /* Mark vldb as backup exists */
+ if (!(entry.flags & VLF_BACKEXISTS)) {
+ entry.flags |= VLF_BACKEXISTS;
vldbmod = 1;
}
/* Now go back to the backup volume and bring it on line */
- code = AFSVolTransCreate(aconn, backupID, apart, ITOffline, &btid);
+ code = AFSVolTransCreate_retry(aconn, backupID, apart, ITOffline, &btid);
if (code) {
fprintf(STDERR,
"Failed to start a transaction on the backup volume %lu\n",
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_int32 avolid,
- afs_int32 acloneid, char *aname, int flags)
+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;
afs_int32 ttid = 0, btid = 0;
afs_int32 code = 0, rcode = 0;
char vname[VOLSER_MAXVOLNAME + 1];
afs_int32 error = 0;
- int backexists = 1;
volEntries volumeInfo;
+ int type = 0;
aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT);
VDONE;
}
- /* Test to see if the clone volume exists by trying to create
- * a transaction on the clone volume. We've assumed the clone exists.
- */
- /* XXX I wonder what happens if the clone has some other parent... */
- code = AFSVolTransCreate(aconn, acloneid, apart, ITOffline, &btid);
- if (code) {
- if (code != VNOVOL) {
- fprintf(STDERR, "Could not reach the clone volume %lu\n",
- (unsigned long)acloneid);
- error = code;
- goto bfail;
- }
- backexists = 0; /* backup volume does not exist */
- }
- if (btid) {
- code = AFSVolEndTrans(aconn, btid, &rcode);
- btid = 0;
- if (code || rcode) {
- fprintf(STDERR,
- "Could not end transaction on the previous clone volume %lu\n",
- (unsigned long)acloneid);
- error = (code ? code : rcode);
- goto bfail;
- }
- }
+ if (flags & RV_RWONLY)
+ type = readwriteVolume;
+ else if (flags & RV_RDONLY)
+ type = readonlyVolume;
+ else
+ type = backupVolume;
- /* Now go ahead and try to clone the RW volume.
- * First start a transaction on the RW volume
- */
- code = AFSVolTransCreate(aconn, avolid, apart, ITBusy, &ttid);
+ code = DoVolClone(aconn, avolid, apart, type, acloneid, "clone",
+ NULL, aname, NULL, NULL, NULL);
if (code) {
- fprintf(STDERR, "Could not start a transaction on the volume %lu\n",
- (unsigned long)avolid);
error = code;
goto bfail;
}
- /* Clone or reclone the volume, depending on whether the backup
- * volume exists or not
- */
- if (backexists) {
- VPRINT1("Re-cloning clone volume %u ...", acloneid);
-
- code = AFSVolReClone(aconn, ttid, acloneid);
- if (code) {
- fprintf(STDERR, "Could not re-clone backup volume %lu\n",
- (unsigned long)acloneid);
- error = code;
- goto bfail;
- }
- } else {
- VPRINT1("Creating a new clone %u ...", acloneid);
-
- code = AFSVolClone(aconn, ttid, 0,
- (flags & RV_RDONLY) ? readonlyVolume : backupVolume,
- aname, &acloneid);
- if (code) {
- fprintf(STDERR, "Failed to clone the volume %lu\n",
- (unsigned long)avolid);
- error = code;
- goto bfail;
- }
- }
-
- /* End the transaction on the RW volume */
- code = AFSVolEndTrans(aconn, ttid, &rcode);
- ttid = 0;
- if (code || rcode) {
- fprintf(STDERR,
- "Failed to end the transaction on the rw volume %lu\n",
- (unsigned long)avolid);
- error = (code ? code : rcode);
- goto bfail;
- }
-
/* Now go back to the backup volume and bring it on line */
if (!(flags & RV_OFFLINE)) {
- code = AFSVolTransCreate(aconn, acloneid, apart, ITOffline, &btid);
+ code = AFSVolTransCreate_retry(aconn, acloneid, apart, ITOffline, &btid);
if (code) {
fprintf(STDERR,
"Failed to start a transaction on the clone volume %lu\n",
return error;
}
-static int
-DelVol(struct rx_connection *conn, afs_int32 vid, afs_int32 part,
- afs_int32 flags)
-{
- afs_int32 acode, ccode, rcode, tid;
- ccode = rcode = tid = 0;
-
- acode = AFSVolTransCreate(conn, vid, part, flags, &tid);
- if (!acode) { /* It really was there */
- acode = AFSVolDeleteVolume(conn, tid);
- if (acode) {
- fprintf(STDERR, "Failed to delete volume %lu.\n",
- (unsigned long)vid);
- PrintError("", acode);
- }
- ccode = AFSVolEndTrans(conn, tid, &rcode);
- if (!ccode)
- ccode = rcode;
- if (ccode) {
- fprintf(STDERR, "Failed to end transaction on volume %lu.\n",
- (unsigned long)vid);
- PrintError("", ccode);
- }
- }
-
- return acode;
-}
-
-#define ONERROR(ec, ep, es) if (ec) { fprintf(STDERR, (es), (ep)); error = (ec); goto rfail; }
-#define ERROREXIT(ec) { error = (ec); goto rfail; }
+#define ONERROR(ec, ep, es) do { \
+ if (ec) { \
+ fprintf(STDERR, (es), (ep)); \
+ error = (ec); \
+ goto rfail; \
+ } \
+} while (0)
+#define ONERROR0(ec, es) do { \
+ if (ec) { \
+ fprintf(STDERR, (es)); \
+ error = (ec); \
+ goto rfail; \
+ } \
+} while (0)
+#define ERROREXIT(ec) do { \
+ error = (ec); \
+ goto rfail; \
+} while (0)
-/* 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_int32 *origflags, afs_uint32 tmpVolId)
{
- afs_int32 volid;
+ afs_uint32 volid;
struct volser_status tstatus;
- int code, rcode, tcode;
+ int code = 0;
+ int rcode, tcode;
+ char hoststr[16];
*connPtr = (struct rx_connection *)0;
*transPtr = 0;
goto fail; /* server is down */
volid = vldbEntryPtr->volumeId[ROVOL];
- if (volid)
+
+ if (volid) {
code =
- AFSVolTransCreate(*connPtr, volid,
+ AFSVolTransCreate_retry(*connPtr, volid,
vldbEntryPtr->serverPartition[index], ITOffline,
transPtr);
+ if (!code && (origflags[index] & VLSF_DONTUSE)) {
+ /* If RO_DONTUSE is set, this is supposed to be an entirely new
+ * site. Don't trust any data on it, since it is possible we
+ * have encountered some temporary volume from some other
+ * incomplete volume operation. It is difficult to detect if
+ * that has happened vs if this is a legit volume, so just
+ * delete it to be safe. */
+
+ VPRINT1("Deleting extant RO_DONTUSE site on %s...",
+ noresolve ? afs_inet_ntoa_r(vldbEntryPtr->
+ serverNumber[index], hoststr) :
+ hostutil_GetNameByINet(vldbEntryPtr->
+ serverNumber[index]));
+
+ code = AFSVolDeleteVolume(*connPtr, *transPtr);
+ if (code) {
+ PrintError("Failed to delete RO_DONTUSE site: ", code);
+ goto fail;
+ }
+
+ tcode = AFSVolEndTrans(*connPtr, *transPtr, &rcode);
+ *transPtr = 0;
+ if (!tcode) {
+ tcode = rcode;
+ }
+ if (tcode) {
+ PrintError("Failed to end transaction on RO_DONTUSE site: ",
+ tcode);
+ goto fail;
+ }
+
+ VDONE;
+
+ /* emulate what TransCreate would have returned, so we try to
+ * create the volume below */
+ code = VNOVOL;
+ }
+ }
+
/* If the volume does not exist, create it */
if (!volid || code) {
- char volname[64];
+ char volname[VL_MAXNAMELEN];
+ char hoststr[16];
if (volid && (code != VNOVOL)) {
PrintError("Failed to start a transaction on the RO volume.\n",
goto fail;
}
- strcpy(volname, vldbEntryPtr->name);
- strcat(volname, ".readonly");
+ strlcpy(volname, vldbEntryPtr->name, sizeof(volname));
+
+ if (strlcat(volname,
+ tmpVolId?".roclone":".readonly",
+ sizeof(volname)) >= sizeof(volname)) {
+ code = ENOMEM;
+ PrintError("Volume name is too long\n", code);
+ goto fail;
+ }
if (verbose) {
fprintf(STDOUT,
"Creating new volume %lu on replication site %s: ",
- (unsigned long)volid,
- hostutil_GetNameByINet(vldbEntryPtr->
+ tmpVolId?(unsigned long)tmpVolId:(unsigned long)volid,
+ noresolve ? afs_inet_ntoa_r(vldbEntryPtr->
+ serverNumber[index], hoststr) :
+ hostutil_GetNameByINet(vldbEntryPtr->
serverNumber[index]));
fflush(STDOUT);
}
code =
- AFSVolCreateVolume(*connPtr, vldbEntryPtr->serverPartition[index],
- volname, volser_RO,
- vldbEntryPtr->volumeId[RWVOL], &volid,
- transPtr);
+ AFSVolCreateVolume(*connPtr, vldbEntryPtr->serverPartition[index],
+ volname, volser_RO,
+ vldbEntryPtr->volumeId[RWVOL],
+ tmpVolId?&tmpVolId:&volid,
+ transPtr);
if (code) {
PrintError("Failed to create the ro volume: ", code);
goto fail;
}
/* 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,
- hostutil_GetNameByINet(vldbEntryPtr->serverNumber[index]));
+ noresolve ? afs_inet_ntoa_r(vldbEntryPtr->
+ serverNumber[index], hoststr) :
+ hostutil_GetNameByINet(vldbEntryPtr->serverNumber[index]));
code = AFSVolGetStatus(*connPtr, *transPtr, &tstatus);
if (code) {
code);
goto fail;
}
+ if (tmpVolId) {
+ code = AFSVolEndTrans(*connPtr, *transPtr, &rcode);
+ *transPtr = 0;
+ if (!code)
+ code = rcode;
+ if (!code)
+ code = DoVolClone(*connPtr, volid,
+ vldbEntryPtr->serverPartition[index],
+ readonlyVolume, tmpVolId, "temporary",
+ vldbEntryPtr->name, NULL, ".roclone", NULL,
+ transPtr);
+ if (code)
+ goto fail;
+ }
*crtimePtr = CLOCKADJ(tstatus.creationDate);
*uptimePtr = CLOCKADJ(tstatus.updateDate);
}
*transPtr = 0;
if (!tcode)
tcode = rcode;
- if (tcode)
+ if (tcode && tcode != ENOENT)
PrintError("Could not end transaction on a ro volume: ", tcode);
}
afs_int32 fromdate, manyDests * tr, afs_int32 flags,
void *cookie, manyResults * results)
{
- int i;
+ unsigned int i;
for (i = 0; i < tr->manyDests_len; i++) {
results->manyResults_val[i] =
return 0;
}
-
-/* UV_ReleaseVolume()
- * Release volume <afromvol> on <afromserver> <afrompart> to all
- * its RO sites (full release). Unless the previous release was
- * incomplete: in which case we bring the remaining incomplete
- * volumes up to date with the volumes that were released
- * successfully.
- * forceflag: Performs a full release.
+/**
+ * Check if a trans has timed out, and recreate it if necessary.
+ *
+ * @param[in] aconn RX connection to the relevant server
+ * @param[inout] atid Transaction ID to check; if we recreated the trans,
+ * contains the new trans ID on success
+ * @param[in] apart Partition for the transaction
+ * @param[in] astat The status of the original transaction
*
- * 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.
+ * @return operation status
+ * @retval 0 existing transaction is still valid, or we managed to recreate
+ * the trans successfully
+ * @retval nonzero Fatal error; bail out
*/
+static int
+CheckTrans(struct rx_connection *aconn, afs_int32 *atid, afs_int32 apart,
+ struct volser_status *astat)
+{
+ struct volser_status new_status;
+ afs_int32 code;
+
+ memset(&new_status, 0, sizeof(new_status));
+ code = AFSVolGetStatus(aconn, *atid, &new_status);
+ if (code) {
+ if (code == ENOENT) {
+ *atid = 0;
+ VPRINT1("Old transaction on cloned volume %lu timed out, "
+ "restarting transaction\n", (long unsigned) astat->volID);
+ code = AFSVolTransCreate_retry(aconn, astat->volID, apart,
+ ITBusy, atid);
+ if (code) {
+ PrintError("Failed to recreate cloned RO volume transaction\n",
+ code);
+ return 1;
+ }
+
+ memset(&new_status, 0, sizeof(new_status));
+ code = AFSVolGetStatus(aconn, *atid, &new_status);
+ if (code) {
+ PrintError("Failed to get status on recreated transaction\n",
+ code);
+ return 1;
+ }
+
+ if (memcmp(&new_status, astat, sizeof(new_status)) != 0) {
+ PrintError("Recreated transaction on cloned RO volume, but "
+ "the volume has changed!\n", 0);
+ return 1;
+ }
+ } else {
+ PrintError("Unable to get status of current cloned RO transaction\n",
+ code);
+ return 1;
+ }
+ } else {
+ if (memcmp(&new_status, astat, sizeof(new_status)) != 0) {
+ /* sanity check */
+ PrintError("Internal error: current GetStatus does not match "
+ "original GetStatus?\n", 0);
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+static void
+PutTrans(afs_int32 *vldbindex, struct replica *replicas,
+ struct rx_connection **toconns, struct release *times,
+ afs_int32 volcount)
+{
+ afs_int32 s, code = 0, rcode = 0;
+ /* End the transactions and destroy the connections */
+ for (s = 0; s < volcount; s++) {
+ if (replicas[s].trans) {
+ code = AFSVolEndTrans(toconns[s], replicas[s].trans, &rcode);
+
+ replicas[s].trans = 0;
+ if (!code)
+ code = rcode;
+ if (code) {
+ if ((s == 0) || (code != ENOENT)) {
+ PrintError("Could not end transaction on a ro volume: ",
+ code);
+ } else {
+ PrintError
+ ("Transaction timed out on a ro volume. Will retry.\n",
+ 0);
+ if (times[s].vldbEntryIndex < *vldbindex)
+ *vldbindex = times[s].vldbEntryIndex;
+ }
+ }
+ }
+ if (toconns[s])
+ rx_DestroyConnection(toconns[s]);
+ toconns[s] = 0;
+ }
+}
+/**
+ * Release a volume to read-only sites
+ *
+ * Release volume <afromvol> on <afromserver> <afrompart> to all
+ * its RO sites (full release). Unless the previous release was
+ * incomplete: in which case we bring the remaining incomplete
+ * volumes up to date with the volumes that were released
+ * successfully.
+ *
+ * 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.
+ *
+ * @param[in] afromvol volume to be released
+ * @param[in] afromserver server containing afromvol
+ * @param[in] afrompart partition containing afromvol
+ * @param[in] flags bitmap of options
+ * REL_COMPLETE - force a complete release
+ * REL_FULLDUMPS - force full dumps
+ */
int
-UV_ReleaseVolume(afs_int32 afromvol, afs_int32 afromserver,
- afs_int32 afrompart, int forceflag)
+UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
+ afs_int32 afrompart, int flags)
{
char vname[64];
- afs_int32 code, vcode, rcode, tcode;
- afs_int32 cloneVolId, roVolId;
+ afs_int32 code = 0;
+ afs_int32 vcode, rcode, tcode;
+ afs_uint32 cloneVolId = 0, roVolId;
struct replica *replicas = 0;
struct nvldbentry entry, storeEntry;
- int i, volcount, m, fullrelease, vldbindex;
+ int i, volcount = 0, m, vldbindex;
int failure;
struct restoreCookie cookie;
struct rx_connection **toconns = 0;
int islocked = 0;
afs_int32 clonetid = 0, onlinetid;
afs_int32 fromtid = 0;
- afs_uint32 fromdate, thisdate;
+ afs_uint32 fromdate = 0;
+ afs_uint32 thisdate;
time_t tmv;
int s;
manyDests tr;
manyResults results;
int rwindex, roindex, roclone, roexists;
- afs_int32 rwcrdate, rwupdate, clcrdate;
+ afs_uint32 rwcrdate = 0, rwupdate = 0;
+ afs_uint32 clcrdate;
struct rtime {
int validtime;
afs_uint32 uptime;
} remembertime[NMAXNSERVERS];
int releasecount = 0;
struct volser_status volstatus;
-
- memset((char *)remembertime, 0, sizeof(remembertime));
- memset((char *)&results, 0, sizeof(results));
+ char hoststr[16];
+ afs_int32 origflags[NMAXNSERVERS];
+ struct volser_status orig_status;
+ int notreleased = 0;
+ int tried_justnewsites = 0;
+ int justnewsites = 0; /* are we just trying to release to new RO sites? */
+ int sites = 0; /* number of ro sites */
+ int new_sites = 0; /* number of ro sites markes as new */
+
+ typedef enum {
+ CR_RECOVER = 0x0000, /**< not complete: a recovery from a previous failed release */
+ CR_FORCED = 0x0001, /**< complete: forced by caller */
+ CR_LAST_OK = 0x0002, /**< complete: no sites have been marked as new release */
+ CR_ALL_NEW = 0x0004, /**< complete: all sites have been marked as new release */
+ CR_NEW_RW = 0x0008, /**< complete: read-write has changed */
+ CR_RO_MISSING = 0x0010, /**< complete: ro clone is missing */
+ } complete_release_t;
+
+ complete_release_t complete_release = CR_RECOVER;
+
+ memset(remembertime, 0, sizeof(remembertime));
+ memset(&results, 0, sizeof(results));
+ memset(origflags, 0, sizeof(origflags));
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(vcode, entry.name, "Could not update vldb entry for %s.\n");
}
- /* Will we be completing a previously unfinished release. -force overrides */
- for (s = 0, m = 0, fullrelease=0, i=0; (i<entry.nServers); i++) {
- if (entry.serverFlags[i] & ITSROVOL) {
- m++;
- if (entry.serverFlags[i] & NEW_REPSITE) s++;
+ /*
+ * Determine if this is to be a complete release or a recovery of a
+ * previous unfinished release. The previous release is considered to be
+ * unfinished when the clone was successfully distributed to at least one
+ * (but not all) of the read-only sites, as indicated by the NEW_REPSITE
+ * vldb flags.
+ *
+ * The caller can override the vldb flags check using the -force
+ * or -force-reclone flag, to force this to be a complete release.
+ */
+ for (i = 0; i < entry.nServers; i++) {
+ if (entry.serverFlags[i] & VLSF_ROVOL) {
+ sites++;
+ if (entry.serverFlags[i] & VLSF_NEWREPSITE)
+ new_sites++;
+ if (entry.serverFlags[i] & VLSF_DONTUSE)
+ notreleased++;
+ }
+ origflags[i] = entry.serverFlags[i];
+ }
+
+ if (flags & REL_COMPLETE) {
+ complete_release |= CR_FORCED;
+ }
+
+ if (new_sites == 0) {
+ complete_release |= CR_LAST_OK;
+ } else if (new_sites == sites) {
+ complete_release |= CR_ALL_NEW;
+ }
+
+ if ((complete_release & (CR_LAST_OK | CR_ALL_NEW))
+ && !(complete_release & CR_FORCED)) {
+ if (notreleased && notreleased != sites) {
+ /* we have some new unreleased sites. try to just release to those,
+ * if the RW has not changed. The caller can override with -force
+ * or with -force-reclone. */
+ justnewsites = 1;
}
}
- if ((forceflag && !fullrelease) || (s == m) || (s == 0))
- fullrelease = 1;
/* Determine which volume id to use and see if it exists */
- cloneVolId =
- ((fullrelease
- || (entry.cloneId == 0)) ? entry.volumeId[ROVOL] : entry.cloneId);
+ cloneVolId = (complete_release || entry.cloneId == 0)
+ ? entry.volumeId[ROVOL] : entry.cloneId;
+
code = VolumeExists(afromserver, afrompart, cloneVolId);
roexists = ((code == ENODEV) ? 0 : 1);
ONERROR(-1, afromserver,
"Cannot establish connection with server 0x%x\n");
- if (!fullrelease) {
- if (!roexists)
- fullrelease = 1; /* Do a full release if RO clone does not exist */
- else {
+ if (!complete_release) {
+ if (!roexists) {
+ complete_release |= CR_RO_MISSING; /* Do a complete release if RO clone does not exist */
+ } else {
/* Begin transaction on RW and mark it busy while we query it */
- code = AFSVolTransCreate(
+ code = AFSVolTransCreate_retry(
fromconn, afromvol, afrompart, ITBusy, &fromtid
);
ONERROR(code, afromvol,
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 end transaction on RW volume %u\n");
/* Begin transaction on clone and mark it busy while we query it */
- code = AFSVolTransCreate(
+ code = AFSVolTransCreate_retry(
fromconn, cloneVolId, afrompart, ITBusy, &clonetid
);
ONERROR(code, cloneVolId,
"Failed to end transaction on RW clone %u\n");
if (rwcrdate > clcrdate)
- fullrelease = 2;/* Do a full release if RO clone older than RW */
+ complete_release |= CR_NEW_RW; /* Do a complete release if RO clone older than RW */
}
}
+ if (!complete_release || (complete_release & CR_NEW_RW)) {
+ /* in case the RW has changed, and just to be safe */
+ justnewsites = 0;
+ }
+
if (verbose) {
- switch (fullrelease) {
- case 2:
- fprintf(STDOUT, "RW %lu changed, doing a complete release\n",
- (unsigned long)afromvol);
- break;
- case 1:
- fprintf(STDOUT, "This is a complete release of volume %lu\n",
- (unsigned long)afromvol);
- break;
- case 0:
- fprintf(STDOUT, "This is a completion of a previous release\n");
- break;
+ if (!complete_release) {
+ fprintf(STDOUT,
+ "This is a recovery of previously failed release\n");
+ } else {
+ fprintf(STDOUT, "This is a complete release of volume %u", afromvol);
+ /* Give the reasons for a complete release, except if only CR_LAST_OK. */
+ if (complete_release != CR_LAST_OK) {
+ char *sep = " (";
+ if (complete_release & CR_FORCED) {
+ fprintf(STDOUT, "%sforced", sep);
+ sep = ", ";
+ }
+ if (complete_release & CR_LAST_OK) {
+ fprintf(STDOUT, "%slast ok", sep);
+ sep = ", ";
+ }
+ if (complete_release & CR_ALL_NEW) {
+ fprintf(STDOUT, "%sall sites are new", sep);
+ sep = ", ";
+ }
+ if (complete_release & CR_NEW_RW) {
+ fprintf(STDOUT, "%srw %u changed", sep, afromvol);
+ sep = ", ";
+ }
+ if (complete_release & CR_RO_MISSING) {
+ fprintf(STDOUT, "%sro clone missing", sep);
+ }
+ fprintf(STDOUT, ")");
+ }
+ fprintf(STDOUT, "\n");
+ if (justnewsites) {
+ tried_justnewsites = 1;
+ fprintf(STDOUT, "There are new RO sites; we will try to "
+ "only release to new sites\n");
+ }
}
}
- if (fullrelease) {
+ if (complete_release) {
+ afs_int32 oldest = 0;
/* If the RO clone exists, then if the clone is a temporary
* clone, delete it. Or if the RO clone is marked RO_DONTUSE
* (it was recently added), then also delete it. We do not
* want to "reclone" a temporary RO clone.
*/
+
+ /* clean up any previous tmp clone before starting if staying up */
if (roexists
- && (!roclone || (entry.serverFlags[roindex] & RO_DONTUSE))) {
- code = DelVol(fromconn, cloneVolId, afrompart, ITOffline);
+ && (!roclone || (entry.serverFlags[roindex] & VLSF_DONTUSE))) {
+ code = DoVolDelete(fromconn,
+ cloneVolId,
+ afrompart, "the", 0, NULL, NULL);
if (code && (code != VNOVOL))
ERROREXIT(code);
roexists = 0;
}
+ if (justnewsites) {
+ VPRINT("Querying old RO sites for update times...");
+ for (vldbindex = 0; vldbindex < entry.nServers; vldbindex++) {
+ volEntries volumeInfo;
+ struct rx_connection *conn;
+ afs_int32 crdate;
+
+ if (!(entry.serverFlags[vldbindex] & VLSF_ROVOL)) {
+ continue;
+ }
+ if ((entry.serverFlags[vldbindex] & VLSF_DONTUSE)) {
+ continue;
+ }
+ conn = UV_Bind(entry.serverNumber[vldbindex], AFSCONF_VOLUMEPORT);
+ if (!conn) {
+ fprintf(STDERR, "Cannot establish connection to server %s\n",
+ hostutil_GetNameByINet(entry.serverNumber[vldbindex]));
+ justnewsites = 0;
+ break;
+ }
+ volumeInfo.volEntries_val = NULL;
+ volumeInfo.volEntries_len = 0;
+ code = AFSVolListOneVolume(conn, entry.serverPartition[vldbindex],
+ entry.volumeId[ROVOL],
+ &volumeInfo);
+ if (code) {
+ fprintf(STDERR, "Could not fetch information about RO vol %lu from server %s\n",
+ (unsigned long)entry.volumeId[ROVOL],
+ hostutil_GetNameByINet(entry.serverNumber[vldbindex]));
+ PrintError("", code);
+ justnewsites = 0;
+ rx_DestroyConnection(conn);
+ break;
+ }
+
+ crdate = CLOCKADJ(volumeInfo.volEntries_val[0].creationDate);
+
+ if (oldest == 0 || crdate < oldest) {
+ oldest = crdate;
+ }
+
+ rx_DestroyConnection(conn);
+ free(volumeInfo.volEntries_val);
+ volumeInfo.volEntries_val = NULL;
+ volumeInfo.volEntries_len = 0;
+ }
+ VDONE;
+ }
+ if (justnewsites) {
+ volEntries volumeInfo;
+ volumeInfo.volEntries_val = NULL;
+ volumeInfo.volEntries_len = 0;
+ code = AFSVolListOneVolume(fromconn, afrompart, afromvol,
+ &volumeInfo);
+ if (code) {
+ fprintf(STDERR, "Could not fetch information about RW vol %lu from server %s\n",
+ (unsigned long)afromvol,
+ hostutil_GetNameByINet(afromserver));
+ PrintError("", code);
+ justnewsites = 0;
+ } else {
+ rwupdate = volumeInfo.volEntries_val[0].updateDate;
+
+ free(volumeInfo.volEntries_val);
+ volumeInfo.volEntries_val = NULL;
+ volumeInfo.volEntries_len = 0;
+ }
+ }
+ if (justnewsites && oldest <= rwupdate) {
+ /* RW has changed */
+ justnewsites = 0;
+ }
+
/* Mark all the ROs in the VLDB entry as RO_DONTUSE. We don't
* write this entry out to the vlserver until after the first
* RO volume is released (temp RO clones don't count).
+ *
+ * If 'justnewsites' is set, we're only updating sites that have
+ * RO_DONTUSE set, so set NEW_REPSITE for all of the others.
*/
for (i = 0; i < entry.nServers; i++) {
- entry.serverFlags[i] &= ~NEW_REPSITE;
- entry.serverFlags[i] |= RO_DONTUSE;
+ if (justnewsites) {
+ if ((entry.serverFlags[i] & VLSF_DONTUSE)) {
+ entry.serverFlags[i] &= ~VLSF_NEWREPSITE;
+ } else {
+ entry.serverFlags[i] |= VLSF_NEWREPSITE;
+ }
+ } else {
+ entry.serverFlags[i] &= ~VLSF_NEWREPSITE;
+ entry.serverFlags[i] |= VLSF_DONTUSE;
+ }
}
- entry.serverFlags[rwindex] |= NEW_REPSITE;
- entry.serverFlags[rwindex] &= ~RO_DONTUSE;
+ entry.serverFlags[rwindex] |= VLSF_NEWREPSITE;
+ entry.serverFlags[rwindex] &= ~VLSF_DONTUSE;
+ }
- /* Begin transaction on RW and mark it busy while we clone it */
- code =
- AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy,
- &clonetid);
- ONERROR(code, afromvol, "Failed to start transaction on volume %u\n");
-
- /* Clone or reclone the volume */
- if (roexists) {
- VPRINT1("Recloning RW volume %u...", cloneVolId);
- code = AFSVolReClone(fromconn, clonetid, cloneVolId);
- ONERROR(code, afromvol, "Failed to reclone the RW volume %u\n");
- VDONE;
+ if (justnewsites && roexists) {
+ /* if 'justnewsites' and 'roexists' are set, we don't need to do
+ * anything with the RO clone, so skip the reclone */
+ /* noop */
+
+ } else if (complete_release) {
+
+ if (roclone) {
+ strcpy(vname, entry.name);
+ strcat(vname, ".readonly");
} else {
- if (roclone) {
- strcpy(vname, entry.name);
- strcat(vname, ".readonly");
- VPRINT1("Cloning RW volume %u to permanent RO...", afromvol);
- } else {
- strcpy(vname, "readonly-clone-temp");
- VPRINT1("Cloning RW volume %u to temporary RO...", afromvol);
+ strcpy(vname, "readonly-clone-temp");
+ }
+
+ code = DoVolClone(fromconn, afromvol, afrompart, readonlyVolume,
+ cloneVolId, roclone?"permanent RO":
+ "temporary RO", NULL, vname, NULL, &volstatus, NULL);
+ if (code) {
+ error = code;
+ goto rfail;
+ }
+
+ if (justnewsites && rwupdate != volstatus.updateDate) {
+ justnewsites = 0;
+ /* reset the serverFlags as if 'justnewsites' had never been set */
+ for (i = 0; i < entry.nServers; i++) {
+ entry.serverFlags[i] &= ~VLSF_NEWREPSITE;
+ entry.serverFlags[i] |= VLSF_DONTUSE;
}
- code =
- AFSVolClone(fromconn, clonetid, 0, readonlyVolume, vname,
- &cloneVolId);
- ONERROR(code, afromvol, "Failed to clone the RW volume %u\n");
- VDONE;
+ entry.serverFlags[rwindex] |= VLSF_NEWREPSITE;
+ entry.serverFlags[rwindex] &= ~VLSF_DONTUSE;
}
- /* Get the time the RW was created for future information */
- VPRINT1("Getting status of RW volume %u...", afromvol);
- code = AFSVolGetStatus(fromconn, clonetid, &volstatus);
- ONERROR(code, afromvol,
- "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);
- code = AFSVolEndTrans(fromconn, clonetid, &rcode);
- clonetid = 0;
- ONERROR((code ? code : rcode), afromvol,
- "Failed to end cloning transaction on RW %u\n");
- VDONE;
/* Remember clone volume ID in case we fail or are interrupted */
entry.cloneId = cloneVolId;
VPRINT1("Starting transaction on RO clone volume %u...",
cloneVolId);
code =
- AFSVolTransCreate(fromconn, cloneVolId, afrompart, ITOffline,
+ AFSVolTransCreate_retry(fromconn, cloneVolId, afrompart, ITOffline,
&onlinetid);
ONERROR(code, cloneVolId,
"Failed to start transaction on volume %u\n");
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.
*/
- if (entry.nServers > 2)
+ if (entry.nServers > 2 && !justnewsites)
sleep(5);
/* Mark the RO clone in the VLDB as a good site (already released) */
- entry.serverFlags[roindex] |= NEW_REPSITE;
- entry.serverFlags[roindex] &= ~RO_DONTUSE;
- entry.flags |= RO_EXISTS;
+ entry.serverFlags[roindex] |= VLSF_NEWREPSITE;
+ entry.serverFlags[roindex] &= ~VLSF_DONTUSE;
+ entry.flags |= VLF_ROEXISTS;
releasecount++;
}
}
+ if (justnewsites) {
+ VPRINT("RW vol has not changed; only releasing to new RO sites\n");
+ /* act like this is a completion of a previous release */
+ complete_release = CR_RECOVER;
+ } else if (tried_justnewsites) {
+ VPRINT("RW vol has changed; releasing to all sites\n");
+ }
+
/* Now we will release from the clone to the remaining RO replicas.
* The first 2 ROs (counting the non-temporary RO clone) are released
* individually: releasecount. This is to reduce the race condition
cookie.parent = entry.volumeId[RWVOL];
cookie.clone = 0;
- nservers = entry.nServers / 2; /* how many to do at once, excluding clone */
- replicas =
- (struct replica *)malloc(sizeof(struct replica) * nservers + 1);
- times = (struct release *)malloc(sizeof(struct release) * nservers + 1);
- toconns =
- (struct rx_connection **)malloc(sizeof(struct rx_connection *) *
- nservers + 1);
- results.manyResults_val =
- (afs_int32 *) malloc(sizeof(afs_int32) * nservers + 1);
- if (!replicas || !times || !!!results.manyResults_val || !toconns)
- ONERROR(ENOMEM, 0,
+ /* how many to do at once, excluding clone */
+ if (justnewsites)
+ nservers = entry.nServers; /* can do all, none offline */
+ else
+ nservers = entry.nServers / 2;
+ replicas = calloc(nservers + 1, sizeof(struct replica));
+ times = calloc(nservers + 1, sizeof(struct release));
+ toconns = calloc(nservers + 1, sizeof(struct rx_connection *));
+ results.manyResults_val = calloc(nservers + 1, sizeof(afs_int32));
+ if (!replicas || !times || !results.manyResults_val || !toconns)
+ ONERROR0(ENOMEM,
"Failed to create transaction on the release clone\n");
- memset(replicas, 0, (sizeof(struct replica) * nservers + 1));
- memset(times, 0, (sizeof(struct release) * nservers + 1));
- memset(toconns, 0, (sizeof(struct rx_connection *) * nservers + 1));
- memset(results.manyResults_val, 0, (sizeof(afs_int32) * nservers + 1));
-
/* Create a transaction on the cloned volume */
VPRINT1("Starting transaction on cloned volume %u...", cloneVolId);
code =
- AFSVolTransCreate(fromconn, cloneVolId, afrompart, ITBusy, &fromtid);
- if (!fullrelease && code)
+ AFSVolTransCreate_retry(fromconn, cloneVolId, afrompart, ITBusy, &fromtid);
+ if (!code) {
+ memset(&orig_status, 0, sizeof(orig_status));
+ code = AFSVolGetStatus(fromconn, fromtid, &orig_status);
+ }
+ if (!complete_release && 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 */
for (vldbindex = 0; vldbindex < entry.nServers;) {
-
- /* Get a transaction on the replicas. Pick replacas which have an old release. */
+ /* Get a transaction on the replicas. Pick replicas which have an old release. */
for (volcount = 0;
((volcount < nservers) && (vldbindex < entry.nServers));
vldbindex++) {
- /* The first two RO volumes will be released individually.
- * The rest are then released in parallel. This is a hack
- * for clients not recognizing right away when a RO volume
- * comes back on-line.
- */
- if ((volcount == 1) && (releasecount < 2))
- break;
+ if (!justnewsites) {
+ /* The first two RO volumes will be released individually.
+ * The rest are then released in parallel. This is a hack
+ * for clients not recognizing right away when a RO volume
+ * comes back on-line.
+ */
+ if ((volcount == 1) && (releasecount < 2))
+ break;
+ }
if (vldbindex == roindex)
continue; /* the clone */
- if ((entry.serverFlags[vldbindex] & NEW_REPSITE)
- && !(entry.serverFlags[vldbindex] & RO_DONTUSE))
+ if ((entry.serverFlags[vldbindex] & VLSF_NEWREPSITE)
+ && !(entry.serverFlags[vldbindex] & VLSF_DONTUSE))
continue;
- if (!(entry.serverFlags[vldbindex] & ITSROVOL))
+ if (!(entry.serverFlags[vldbindex] & VLSF_ROVOL))
continue; /* not a RO vol */
/* 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]);
GetTrans(&entry, vldbindex, &(toconns[volcount]),
&(replicas[volcount].trans),
&(times[volcount].crtime),
- &(times[volcount].uptime));
+ &(times[volcount].uptime),
+ origflags, 0);
if (code)
continue;
/* Thisdate is the date from which we want to pick up all changes */
- if (forceflag || !fullrelease
- || (rwcrdate > times[volcount].crtime)) {
- /* If the forceflag is set, then we want to do a full dump.
- * If it's not a full release, we can't be sure that the creation
- * date is good (so we also do a full dump).
- * If the RW volume was replaced (its creation date is newer than
- * the last release), then we can't be sure what has changed (so
- * we do a full dump).
+ if (flags & REL_FULLDUMPS) {
+ /* Do a full dump when forced by the caller. */
+ VPRINT("This will be a full dump: forced\n");
+ thisdate = 0;
+ } else if (!complete_release) {
+ /* If this release is a recovery of a failed release, we can't be
+ * sure the creation date is good, so do a full dump.
+ */
+ VPRINT("This will be a full dump: previous release failed\n");
+ thisdate = 0;
+ } else if (times[volcount].crtime == 0) {
+ /* A full dump is needed for a new read-only volume. */
+ VPRINT
+ ("This will be a full dump: read-only volume needs to be created\n");
+ thisdate = 0;
+ } else if ((rwcrdate > times[volcount].crtime)) {
+ /* If the RW volume was replaced (its creation date is newer than
+ * the last release), then we can't be sure what has changed (so
+ * we do a full dump).
*/
+ VPRINT
+ ("This will be a full dump: read-write volume was replaced\n");
thisdate = 0;
} else if (remembertime[vldbindex].validtime) {
/* Trans was prev ended. Use the time from the prev trans
if (!volcount)
continue;
+ code = CheckTrans(fromconn, &fromtid, afrompart, &orig_status);
+ if (code) {
+ code = ENOENT;
+ goto rfail;
+ }
+
if (verbose) {
fprintf(STDOUT, "Starting ForwardMulti from %lu to %u on %s",
- (unsigned long)cloneVolId, entry.volumeId[ROVOL],
- hostutil_GetNameByINet(entry.
+ (unsigned long)cloneVolId,
+ entry.volumeId[ROVOL],
+ noresolve ? afs_inet_ntoa_r(entry.serverNumber[times[0].
+ vldbEntryIndex], hoststr) :
+ hostutil_GetNameByINet(entry.
serverNumber[times[0].
vldbEntryIndex]));
for (s = 1; s < volcount; s++) {
fprintf(STDOUT, " and %s",
- hostutil_GetNameByINet(entry.
+ noresolve ? afs_inet_ntoa_r(entry.serverNumber[times[s].
+ vldbEntryIndex], hoststr) :
+ hostutil_GetNameByINet(entry.
serverNumber[times[s].
vldbEntryIndex]));
}
if (fromdate == 0)
- fprintf(STDOUT, " (full release)");
+ fprintf(STDOUT, " (entire volume)");
else {
tmv = fromdate;
fprintf(STDOUT, " (as of %.24s)", ctime(&tmv));
/* 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) {
continue;
}
- entry.serverFlags[times[m].vldbEntryIndex] |= NEW_REPSITE;
- entry.serverFlags[times[m].vldbEntryIndex] &= ~RO_DONTUSE;
- entry.flags |= RO_EXISTS;
+ entry.serverFlags[times[m].vldbEntryIndex] |= VLSF_NEWREPSITE;
+ entry.serverFlags[times[m].vldbEntryIndex] &= ~VLSF_DONTUSE;
+ entry.flags |= VLF_ROEXISTS;
releasecount++;
}
}
- /* End the transactions and destroy the connections */
- for (s = 0; s < volcount; s++) {
- if (replicas[s].trans)
- code = AFSVolEndTrans(toconns[s], replicas[s].trans, &rcode);
- replicas[s].trans = 0;
- if (!code)
- code = rcode;
- if (code) {
- if ((s == 0) || (code != ENOENT)) {
- PrintError("Could not end transaction on a ro volume: ",
- code);
- } else {
- PrintError
- ("Transaction timed out on a ro volume. Will retry.\n",
- 0);
- if (times[s].vldbEntryIndex < vldbindex)
- vldbindex = times[s].vldbEntryIndex;
- }
- }
-
- if (toconns[s])
- rx_DestroyConnection(toconns[s]);
- toconns[s] = 0;
- }
-
+ PutTrans(&vldbindex, replicas, toconns, times, volcount);
MapNetworkToHost(&entry, &storeEntry);
vcode = VLDB_ReplaceEntry(afromvol, RWVOL, &storeEntry, 0);
ONERROR(vcode, afromvol,
/* Figure out if any volume were not released and say so */
for (failure = 0, i = 0; i < entry.nServers; i++) {
- if (!(entry.serverFlags[i] & NEW_REPSITE))
+ if (!(entry.serverFlags[i] & VLSF_NEWREPSITE))
failure++;
}
if (failure) {
"The volume %lu could not be released to the following %d sites:\n",
(unsigned long)afromvol, failure);
for (i = 0; i < entry.nServers; i++) {
- if (!(entry.serverFlags[i] & NEW_REPSITE)) {
+ if (!(entry.serverFlags[i] & VLSF_NEWREPSITE)) {
MapPartIdIntoName(entry.serverPartition[i], pname);
fprintf(STDERR, "\t%35s %s\n",
- hostutil_GetNameByINet(entry.serverNumber[i]), pname);
+ noresolve ? afs_inet_ntoa_r(entry.serverNumber[i], hoststr) :
+ hostutil_GetNameByINet(entry.serverNumber[i]), pname);
}
}
-
MapNetworkToHost(&entry, &storeEntry);
vcode =
VLDB_ReplaceEntry(afromvol, RWVOL, &storeEntry,
ERROREXIT(VOLSERBADRELEASE);
}
+ entry.cloneId = 0;
/* All the ROs were release successfully. Remove the temporary clone */
if (!roclone) {
if (verbose) {
(unsigned long)cloneVolId);
fflush(STDOUT);
}
- code = DelVol(fromconn, cloneVolId, afrompart, ITOffline);
+ code = DoVolDelete(fromconn, cloneVolId, afrompart, NULL, 0, NULL,
+ NULL);
ONERROR(code, cloneVolId, "Failed to delete volume %u.\n");
VDONE;
}
- entry.cloneId = 0;
for (i = 0; i < entry.nServers; i++)
- entry.serverFlags[i] &= ~NEW_REPSITE;
+ entry.serverFlags[i] &= ~VLSF_NEWREPSITE;
/* Update the VLDB */
VPRINT("updating VLDB ...");
fprintf(STDERR,
"Failed to end transaction on ro volume %u at server %s\n",
entry.volumeId[ROVOL],
- hostutil_GetNameByINet(htonl
- (replicas[i].server.
- destHost)));
+ noresolve ? afs_inet_ntoa_r(htonl(replicas[i].server.
+ destHost), hoststr) :
+ hostutil_GetNameByINet(htonl
+ (replicas[i].server.destHost)));
if (!error)
error = code;
}
}
-void
+static void
dump_sig_handler(int x)
{
fprintf(STDERR, "\nSignal handler: vos dump operation\n");
/* 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_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
- afs_int32 fromdate, afs_int32(*DumpFunction) (), char *rock,
+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 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(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)
+ code = rx_EndCall(fromcall, 0);
+ 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_int32 afromvol, afs_int32 afromserver,
+UV_DumpClonedVolume(afs_uint32 afromvol, afs_uint32 afromserver,
afs_int32 afrompart, afs_int32 fromdate,
- afs_int32(*DumpFunction) (), char *rock, afs_int32 flags)
+ 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 clonetid = 0;
- afs_int32 code = 0, vcode = 0, error = 0;
- afs_int32 clonevol = 0;
- char vname[64];
+ /* 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, rcode = 0;
+ afs_int32 code = 0, error = 0;
+ afs_uint32 tmpVol;
time_t tmv = fromdate;
+ char *volName = NULL;
if (setjmp(env))
ERROR_EXIT(EPIPE);
fromconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT);
VEPRINT1("Starting transaction on volume %u...", afromvol);
- code = AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy, &fromtid);
+ code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy, &fromtid);
EGOTO1(error_exit, code,
"Could not start transaction on the volume %u to be dumped\n",
afromvol);
VEDONE;
+ VEPRINT1("Getting the name for volume %u ...", afromvol);
+ code = AFSVolGetName(fromconn, fromtid, &volName);
+ EGOTO1(error_exit, code,
+ "Failed to get the name of the volume %u\n",afromvol);
+ VEDONE;
+
/* 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);
/* Do the clone. Default flags on clone are set to delete on salvage and out of service */
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, volName, &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(fromconn, clonevol, afrompart, ITOffline,
- &clonetid);
+ AFSVolTransCreate_retry(fromconn, clonevol, afrompart, ITOffline,
+ &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);
VEDONE;
error_exit:
+ if (volName)
+ free(volName);
+
/* now delete the clone */
VEPRINT1("Deleting the cloned volume %u ...", clonevol);
code = AFSVolDeleteVolume(fromconn, clonetid);
}
if (fromcall) {
- code = rx_EndCall(fromcall, rxError);
+ code = rx_EndCall(fromcall, 0);
if (code) {
fprintf(STDERR, "Error in rx_EndCall\n");
if (!error)
/*
* 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_int32 tovolid,
- afs_int32 toparentid, char tovolname[], int flags,
- afs_int32(*WriteData) (), char *rock)
+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 rx_connection *toconn, *tempconn;
struct rx_call *tocall;
afs_int32 totid, code, rcode, vcode, terror = 0;
- afs_int32 rxError = 0;
struct volser_status tstatus;
struct volintInfo vinfo;
char partName[10];
char tovolreal[VOLSER_OLDMAXVOLNAME];
- afs_int32 pvolid, pparentid;
- afs_int32 temptid;
- int success;
+ afs_uint32 pvolid;
+ afs_int32 temptid, pparentid;
struct nvldbentry entry, storeEntry;
afs_int32 error;
int islocked;
int reuseID;
afs_int32 volflag, voltype, volsertype;
afs_int32 oldCreateDate, oldUpdateDate, newCreateDate, newUpdateDate;
+ VolumeId oldCloneId = 0;
+ VolumeId oldBackupId = 0;
int index, same, errcode;
char apartName[10];
-
+ char hoststr[16];
memset(&cookie, 0, sizeof(cookie));
islocked = 0;
- success = 0;
error = 0;
reuseID = 1;
tocall = (struct rx_call *)0;
- toconn = (struct rx_connection *)0;
tempconn = (struct rx_connection *)0;
totid = 0;
temptid = 0;
}
reuseID = 0;
} else if (flags & RV_RDONLY) {
- if (entry.flags & RW_EXISTS) {
+ if (entry.flags & VLF_RWEXISTS) {
fprintf(STDERR,
"Entry for ReadWrite volume %s already exists!\n",
entry.name);
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",
MapPartIdIntoName(topart, partName);
fprintf(STDOUT, "Restoring volume %s Id %lu on server %s partition %s ..",
tovolreal, (unsigned long)pvolid,
+ noresolve ? afs_inet_ntoa_r(toserver, hoststr) :
hostutil_GetNameByINet(toserver), partName);
fflush(STDOUT);
code =
&totid);
if (code) {
if (flags & RV_FULLRST) { /* full restore: delete then create anew */
- VPRINT1("Deleting the previous volume %u ...", pvolid);
-
- code =
- AFSVolTransCreate(toconn, pvolid, topart, ITOffline, &totid);
- EGOTO1(refail, code, "Failed to start transaction on %u\n",
- pvolid);
-
- code = AFSVolGetStatus(toconn, totid, &tstatus);
- EGOTO1(refail, code, "Could not get timestamp from volume %u\n",
- pvolid);
-
- oldCreateDate = tstatus.creationDate;
- oldUpdateDate = tstatus.updateDate;
-
- code =
- AFSVolSetFlags(toconn, totid,
- VTDeleteOnSalvage | VTOutOfService);
- EGOTO1(refail, code, "Could not set flags on volume %u \n",
- pvolid);
-
- code = AFSVolDeleteVolume(toconn, totid);
- EGOTO1(refail, code, "Could not delete volume %u\n", pvolid);
-
- code = AFSVolEndTrans(toconn, totid, &rcode);
- totid = 0;
- if (!code)
- code = rcode;
- EGOTO1(refail, code, "Could not end transaction on %u\n", pvolid);
-
- VDONE;
+ code = DoVolDelete(toconn, pvolid, topart, "the previous", 0,
+ &tstatus, NULL);
+ if (code && code != VNOVOL) {
+ error = code;
+ goto refail;
+ }
code =
AFSVolCreateVolume(toconn, topart, tovolreal, volsertype, pparentid,
EGOTO1(refail, code, "Could not create new volume %u\n", pvolid);
} else {
code =
- AFSVolTransCreate(toconn, pvolid, topart, ITOffline, &totid);
+ AFSVolTransCreate_retry(toconn, pvolid, topart, ITOffline, &totid);
EGOTO1(refail, code, "Failed to start transaction on %u\n",
pvolid);
EGOTO1(refail, code, "Could not get timestamp from volume %u\n",
pvolid);
- oldCreateDate = tstatus.creationDate;
- oldUpdateDate = tstatus.updateDate;
}
+ oldCreateDate = tstatus.creationDate;
+ oldUpdateDate = tstatus.updateDate;
+ oldCloneId = tstatus.cloneID;
+ oldBackupId = tstatus.backupID;
} else {
oldCreateDate = 0;
oldUpdateDate = 0;
error = code;
goto refail;
}
- terror = rx_EndCall(tocall, rxError);
+ terror = rx_EndCall(tocall, 0);
tocall = (struct rx_call *)0;
if (terror) {
fprintf(STDERR, "rx_EndCall Failed \n");
error = code;
goto refail;
}
- code = AFSVolSetIdsTypes(toconn, totid, tovolreal, voltype, pparentid, 0, 0);
+ code = AFSVolSetIdsTypes(toconn, totid, tovolreal, voltype, pparentid,
+ oldCloneId, oldBackupId);
if (code) {
- fprintf(STDERR, "Could not set the right type and ID on %lu\n",
+ fprintf(STDERR, "Could not set the right type and IDs on %lu\n",
(unsigned long)pvolid);
error = code;
goto refail;
goto refail;
}
- success = 1;
fprintf(STDOUT, " done\n");
fflush(STDOUT);
- if (success && (!reuseID || (flags & RV_FULLRST))) {
- /* Volume was restored on the file server, update the
+ if (!reuseID || (flags & RV_FULLRST)) {
+ /* Volume was restored on the file server, update the
* VLDB to reflect the change.
*/
vcode = VLDB_GetEntryByID(pvolid, voltype, &entry);
entry.nServers = 1;
entry.serverNumber[0] = toserver; /*should be indirect */
entry.serverPartition[0] = topart;
- entry.serverFlags[0] = (flags & RV_RDONLY) ? ITSROVOL : ITSRWVOL;
- entry.flags = (flags & RV_RDONLY) ? RO_EXISTS : RW_EXISTS;
+ entry.serverFlags[0] = (flags & RV_RDONLY) ? VLSF_ROVOL : VLSF_RWVOL;
+ entry.flags = (flags & RV_RDONLY) ? VLF_ROEXISTS : VLF_RWEXISTS;
if (flags & RV_RDONLY)
entry.volumeId[ROVOL] = pvolid;
else if (tstatus.cloneID != 0) {
entry.serverNumber[entry.nServers] = toserver;
entry.serverPartition[entry.nServers] = topart;
entry.serverFlags[entry.nServers] =
- (flags & RV_RDONLY) ? ITSROVOL : ITSRWVOL;
+ (flags & RV_RDONLY) ? VLSF_ROVOL : VLSF_RWVOL;
entry.nServers++;
} else {
/* This volume should be deleted on the old site
VPRINT2
("Not deleting the previous volume %u on server %s, ...",
pvolid,
+ noresolve ? afs_inet_ntoa_r(entry.serverNumber[index], hoststr) :
hostutil_GetNameByINet(entry.serverNumber[index]));
} else {
tempconn =
UV_Bind(entry.serverNumber[index],
AFSCONF_VOLUMEPORT);
-
+
MapPartIdIntoName(entry.serverPartition[index],
apartName);
VPRINT3
("Deleting the previous volume %u on server %s, partition %s ...",
pvolid,
+ noresolve ? afs_inet_ntoa_r(entry.serverNumber[index], hoststr) :
hostutil_GetNameByINet(entry.serverNumber[index]),
apartName);
- code =
- AFSVolTransCreate(tempconn, pvolid,
- entry.serverPartition[index],
- ITOffline, &temptid);
- if (!code) {
- code =
- AFSVolSetFlags(tempconn, temptid,
- VTDeleteOnSalvage |
- VTOutOfService);
- if (code) {
- fprintf(STDERR,
- "Could not set flags on volume %lu on the older site\n",
- (unsigned long)pvolid);
- error = code;
- goto refail;
- }
- code = AFSVolDeleteVolume(tempconn, temptid);
- if (code) {
- fprintf(STDERR,
- "Could not delete volume %lu on the older site\n",
- (unsigned long)pvolid);
- error = code;
- goto refail;
- }
- code = AFSVolEndTrans(tempconn, temptid, &rcode);
- temptid = 0;
- if (!code)
- code = rcode;
- if (code) {
- fprintf(STDERR,
- "Could not end transaction on volume %lu on the older site\n",
- (unsigned long)pvolid);
- error = code;
- goto refail;
- }
- VDONE;
- MapPartIdIntoName(entry.serverPartition[index],
- partName);
+ code = DoVolDelete(tempconn, pvolid,
+ entry.serverPartition[index],
+ "the", 0, NULL, NULL);
+ if (code && code != VNOVOL) {
+ error = code;
+ goto refail;
}
+ MapPartIdIntoName(entry.serverPartition[index],
+ partName);
}
}
entry.serverNumber[index] = toserver;
entry.serverPartition[index] = topart;
}
- entry.flags |= (flags & RV_RDONLY) ? RO_EXISTS : RW_EXISTS;
+ entry.flags |= (flags & RV_RDONLY) ? VLF_ROEXISTS : VLF_RWEXISTS;
MapNetworkToHost(&entry, &storeEntry);
vcode =
VLDB_ReplaceEntry(pvolid, voltype, &storeEntry,
}
refail:
if (tocall) {
- code = rx_EndCall(tocall, rxError);
+ code = rx_EndCall(tocall, 0);
if (!error)
error = code;
}
}
int
-UV_RestoreVolume(afs_int32 toserver, afs_int32 topart, afs_int32 tovolid,
- char tovolname[], int flags, afs_int32(*WriteData) (),
- char *rock)
+UV_RestoreVolume(afs_uint32 toserver, afs_int32 topart, afs_uint32 tovolid,
+ char tovolname[], int flags,
+ afs_int32(*WriteData) (struct rx_call *, void *),
+ void *rock)
{
return UV_RestoreVolume2(toserver, topart, tovolid, 0, tovolname, flags,
WriteData, rock);
/*unlocks the vldb entry associated with <volid> */
int
-UV_LockRelease(afs_int32 volid)
+UV_LockRelease(afs_uint32 volid)
{
-
-
afs_int32 vcode;
VPRINT("Binding to the VLDB server\n");
}
+/* 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_int32 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];
/* See if it's on the same server */
for (j = 0; j < entry.nServers; j++) {
- if (entry.serverFlags[j] & ITSROVOL) {
+ if (entry.serverFlags[j] & VLSF_ROVOL) {
nro++;
if (VLDB_IsSameAddrs(server, entry.serverNumber[j], &error)) {
if (error) {
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;
if (!valid) {
- entry.serverFlags[entry.nServers] = (ITSROVOL | RO_DONTUSE);
+ entry.serverFlags[entry.nServers] = (VLSF_ROVOL | VLSF_DONTUSE);
} else {
- entry.serverFlags[entry.nServers] = (ITSROVOL);
+ entry.serverFlags[entry.nServers] = (VLSF_ROVOL);
}
entry.nServers++;
/*removes <server> <part> as read only site for <volid> from the vldb */
int
-UV_RemoveSite(afs_int32 server, afs_int32 part, afs_int32 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,
} else { /*remove the rep site */
Lp_SetROValue(&entry, server, part, 0, 0);
entry.nServers--;
- if ((entry.nServers == 1) && (entry.flags & RW_EXISTS))
- entry.flags &= ~RO_EXISTS;
+ if ((entry.nServers == 1) && (entry.flags & VLF_RWEXISTS))
+ entry.flags &= ~VLF_ROEXISTS;
if (entry.nServers < 1) { /*this is the last ref */
VPRINT1("Deleting the VLDB entry for %u ...", volid);
fflush(STDOUT);
/*sets <server> <part> as read/write site for <volid> in the vldb */
int
-UV_ChangeLocation(afs_int32 server, afs_int32 part, afs_int32 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;
struct volDescription *curPtr;
int curPos;
afs_int32 code = 0;
- afs_int32 rcode = 0;
afs_int32 success = 1;
- afs_int32 tid;
- aconn = (struct rx_connection *)0;
aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT);
curPos = 0;
for (curPtr = volPtr; curPos < arraySize; curPtr++) {
if (curPtr->volFlags & CLONEVALID) {
curPtr->volFlags &= ~CLONEZAPPED;
success = 1;
- code =
- AFSVolTransCreate(aconn, curPtr->volCloneId, apart, ITOffline,
- &tid);
+
+ code = DoVolDelete(aconn, curPtr->volCloneId, apart,
+ "clone", 0, NULL, NULL);
if (code)
success = 0;
- else {
- code = AFSVolDeleteVolume(aconn, tid);
- if (code)
- success = 0;
- code = AFSVolEndTrans(aconn, tid, &rcode);
- if (code || rcode)
- success = 0;
- }
+
if (success)
curPtr->volFlags |= CLONEZAPPED;
if (!success)
VPRINT2("Clone of %s %u deleted\n", curPtr->volName,
curPtr->volCloneId);
curPos++;
- tid = 0;
}
}
if (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;
afs_int32 rcode = 0;
afs_int32 tid;
int reuseCloneId = 0;
- afs_int32 curCloneId = 0;
+ afs_uint32 curCloneId = 0;
char cloneName[256]; /*max vol name */
- aconn = (struct rx_connection *)0;
aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT);
curPos = 0;
if ((volPtr->volFlags & REUSECLONEID) && (volPtr->volFlags & ENTRYVALID))
curPtr->volFlags |= CLONEVALID;
/*make a clone of curParentId and record as curPtr->volCloneId */
code =
- AFSVolTransCreate(aconn, curPtr->volId, apart, ITOffline,
+ AFSVolTransCreate_retry(aconn, curPtr->volId, apart, ITOffline,
&tid);
if (code)
VPRINT2("Clone for volume %s %u failed \n", curPtr->volName,
/*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)
{
* We set the val field to a null pointer as a hint for the stub to
* allocate space.
*/
- code = 0;
*a_numEntsInResultP = 0;
*a_resultPP = (volintXInfo *) 0;
volumeXInfo.volXEntries_val = (volintXInfo *) 0;
/* get all the information about volume <volid> on <aserver> and <apart> */
int
-UV_ListOneVolume(afs_int32 aserver, afs_int32 apart, afs_int32 volid,
+UV_ListOneVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 volid,
struct volintInfo **resultPtr)
{
struct rx_connection *aconn;
afs_int32 code = 0;
volEntries volumeInfo;
- code = 0;
-
*resultPtr = (volintInfo *) 0;
volumeInfo.volEntries_val = (volintInfo *) 0; /*this hints the stub to allocate space */
volumeInfo.volEntries_len = 0;
*------------------------------------------------------------------------*/
int
-UV_XListOneVolume(afs_int32 a_serverID, afs_int32 a_partID, afs_int32 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 */
* the info. Setting the val field to a null pointer tells the stub
* to allocate space for us.
*/
- code = 0;
*a_resultPP = (volintXInfo *) 0;
volumeXInfo.volXEntries_val = (volintXInfo *) 0;
volumeXInfo.volXEntries_len = 0;
}
/* 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, j;
+ 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;
- afs_int32 rwvolid;
+ int pass = 0, createentry, addvolume, modified, mod, doit = 1;
+ afs_uint32 rwvolid;
+ 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 retrieve 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)) {
if (createentry) {
fprintf(STDOUT, "\n**does not exist**\n");
} else {
- if ((entry.flags & RW_EXISTS) || (entry.flags & RO_EXISTS)
- || (entry.flags & BACK_EXISTS))
+ if ((entry.flags & VLF_RWEXISTS) || (entry.flags & VLF_ROEXISTS)
+ || (entry.flags & VLF_BACKEXISTS))
EnumerateEntry(&entry);
}
fprintf(STDOUT, "\n");
} else { /* RW index found in the VLDB entry. */
/* Verify if this volume's location matches where the VLDB says it is */
if (!Lp_Match(aserver, apart, &entry)) {
- if (entry.flags & RW_EXISTS) {
+ if (entry.flags & VLF_RWEXISTS) {
/* The RW volume exists elsewhere - report this one a duplicate */
if (pass == 1) {
MapPartIdIntoName(apart, pname);
fprintf(STDERR,
"*** Warning: Orphaned RW volume %lu exists on %s %s\n",
(unsigned long)rwvolid,
+ noresolve ?
+ afs_inet_ntoa_r(aserver, hoststr) :
hostutil_GetNameByINet(aserver), pname);
MapPartIdIntoName(entry.serverPartition[idx],
pname);
fprintf(STDERR,
" VLDB reports RW volume %lu exists on %s %s\n",
(unsigned long)rwvolid,
+ noresolve ?
+ afs_inet_ntoa_r(entry.serverNumber[idx], hoststr) :
hostutil_GetNameByINet(entry.
serverNumber[idx]),
pname);
addvolume++;
/* Check for orphaned BK volume on old partition */
- if (entry.flags & BACK_EXISTS) {
+ if (entry.flags & VLF_BACKEXISTS) {
if (pass == 1) {
MapPartIdIntoName(entry.serverPartition[idx],
pname);
fprintf(STDERR,
"*** Warning: Orphaned BK volume %u exists on %s %s\n",
entry.volumeId[BACKVOL],
+ noresolve ?
+ afs_inet_ntoa_r(entry.serverNumber[idx], hoststr) :
hostutil_GetNameByINet(entry.
serverNumber
[idx]), pname);
fprintf(STDERR,
" VLDB reports its RW volume %lu exists on %s %s\n",
(unsigned long)rwvolid,
+ noresolve ?
+ afs_inet_ntoa_r(aserver, hoststr) :
hostutil_GetNameByINet(aserver),
pname);
}
}
if (addvolume) {
- entry.flags |= RW_EXISTS;
+ entry.flags |= VLF_RWEXISTS;
entry.volumeId[RWVOL] = rwvolid;
if (!entry.volumeId[BACKVOL])
entry.volumeId[BACKVOL] = volumeinfo->backupID;
if (!entry.volumeId[ROVOL])
entry.volumeId[ROVOL] = volumeinfo->cloneID;
- entry.serverFlags[idx] = ITSRWVOL;
+ entry.serverFlags[idx] = VLSF_RWVOL;
entry.serverNumber[idx] = aserver;
entry.serverPartition[idx] = apart;
strncpy(entry.name, volumeinfo->name, VOLSER_OLDMAXVOLNAME);
fprintf(STDERR,
"*** Warning: Orphaned BK volume %lu exists on %s %s\n",
(unsigned long)volumeinfo->volid,
+ noresolve ?
+ afs_inet_ntoa_r(aserver, hoststr) :
hostutil_GetNameByINet(aserver), pname);
MapPartIdIntoName(entry.serverPartition[idx], pname);
fprintf(STDERR,
" VLDB reports its RW/BK volume %lu exists on %s %s\n",
(unsigned long)rwvolid,
+ noresolve ?
+ afs_inet_ntoa_r(entry.serverNumber[idx], hoststr) :
hostutil_GetNameByINet(entry.
serverNumber[idx]),
pname);
}
} else {
if (volumeinfo->volid != entry.volumeId[BACKVOL]) {
- if (!(entry.flags & BACK_EXISTS)) {
+ if (!(entry.flags & VLF_BACKEXISTS)) {
addvolume++;
} else if (volumeinfo->volid >
entry.volumeId[BACKVOL]) {
fprintf(STDERR,
"*** Warning: Orphaned BK volume %u exists on %s %s\n",
entry.volumeId[BACKVOL],
+ noresolve ?
+ afs_inet_ntoa_r(aserver, hoststr) :
hostutil_GetNameByINet(aserver),
pname);
fprintf(STDERR,
pname);
fprintf(STDERR,
"*** Warning: Orphaned BK volume %lu exists on %s %s\n",
- (unsigned long)volumeinfo->volid,
- hostutil_GetNameByINet(aserver),
+ (unsigned long)volumeinfo->volid,
+ noresolve ?
+ afs_inet_ntoa_r(aserver, hoststr) :
+ hostutil_GetNameByINet(aserver),
pname);
fprintf(STDERR,
" VLDB reports its BK volume ID is %u\n",
}
}
if (addvolume) {
- entry.flags |= BACK_EXISTS;
+ entry.flags |= VLF_BACKEXISTS;
entry.volumeId[RWVOL] = rwvolid;
entry.volumeId[BACKVOL] = volumeinfo->volid;
entry.serverNumber[idx] = aserver;
entry.serverPartition[idx] = apart;
- entry.serverFlags[idx] = ITSRWVOL;
+ entry.serverFlags[idx] = VLSF_RWVOL;
modified++;
}
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).
*/
entry.nServers++;
addvolume++;
} else {
- if (!(entry.flags & RO_EXISTS)) {
+ if (!(entry.flags & VLF_ROEXISTS)) {
addvolume++;
}
}
if (mod)
modified++;
- if (!(entry.flags & RO_EXISTS)) {
+ if (!(entry.flags & VLF_ROEXISTS)) {
/* No RO exists in the VLDB entry - add this one */
idx = entry.nServers;
entry.nServers++;
* all the RO volumes listed in VLDB entry and add this volume.
*/
for (j = 0; j < entry.nServers; j++) {
- if (entry.serverFlags[j] & ITSROVOL) {
+ if (entry.serverFlags[j] & VLSF_ROVOL) {
/* Verify this volume exists and print message we are orphaning it */
if (pass == 1) {
MapPartIdIntoName(apart, pname);
fprintf(STDERR,
"*** Warning: Orphaned RO volume %u exists on %s %s\n",
entry.volumeId[ROVOL],
- hostutil_GetNameByINet(entry.
+ noresolve ?
+ afs_inet_ntoa_r(entry.serverNumber[j], hoststr) :
+ hostutil_GetNameByINet(entry.
serverNumber[j]),
pname);
fprintf(STDERR,
MapPartIdIntoName(apart, pname);
fprintf(STDERR,
"*** Warning: Orphaned RO volume %lu exists on %s %s\n",
- (unsigned long)volumeinfo->volid,
- hostutil_GetNameByINet(aserver), pname);
+ (unsigned long)volumeinfo->volid,
+ noresolve ?
+ afs_inet_ntoa_r(aserver, hoststr) :
+ hostutil_GetNameByINet(aserver), pname);
fprintf(STDERR,
" VLDB reports its RO volume ID is %u\n",
entry.volumeId[ROVOL]);
}
if (addvolume) {
- entry.flags |= RO_EXISTS;
+ entry.flags |= VLF_ROEXISTS;
entry.volumeId[RWVOL] = rwvolid;
entry.volumeId[ROVOL] = volumeinfo->volid;
entry.serverNumber[idx] = aserver;
entry.serverPartition[idx] = apart;
- entry.serverFlags[idx] = ITSROVOL;
+ entry.serverFlags[idx] = VLSF_ROVOL;
modified++;
}
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);
return (error);
}
-int
+static int
sortVolumes(const void *a, const void *b)
{
volintInfo *v1 = (volintInfo *) a;
volintInfo *v2 = (volintInfo *) b;
- afs_int32 rwvolid1, rwvolid2;
+ afs_uint32 rwvolid1, rwvolid2;
rwvolid1 = ((v1->type == RWVOL) ? v1->volid : v1->parentID);
rwvolid2 = ((v2->type == RWVOL) ? v2->volid : v2->parentID);
* 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, mod, modified = 0;
+ afs_int32 tverbose;
+ afs_int32 mod, modified = 0, deleted = 0;
struct nvldbentry vldbentry;
- afs_int32 volumeid = 0;
+ afs_uint32 volumeid = 0;
volEntries volumeInfo;
struct partList PartList;
- afs_int32 pcnt, rv;
- afs_int32 maxvolid = 0;
+ afs_int32 pcnt;
+ afs_uint32 maxvolid = 0;
volumeInfo.volEntries_val = (volintInfo *) 0;
volumeInfo.volEntries_len = 0;
- if (!aserver && (flags & 1)) {
- /* fprintf(STDERR,"Partition option requires a server option\n"); */
- ERROR_EXIT(EINVAL);
- }
-
/* 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;
+ if (!aserver && (flags & 1)) {
+ /* fprintf(STDERR,"Partition option requires a server option\n"); */
+ ERROR_EXIT(EINVAL);
+ }
+
/* Read the VLDB entry */
vcode = VLDB_GetEntryByName(avolname, &vldbentry);
if (vcode && (vcode != VL_NOENT)) {
if (vcode) {
fprintf(STDOUT, "\n**does not exist**\n");
} else {
- if ((vldbentry.flags & RW_EXISTS) || (vldbentry.flags & RO_EXISTS)
- || (vldbentry.flags & BACK_EXISTS))
+ if ((vldbentry.flags & VLF_RWEXISTS) || (vldbentry.flags & VLF_ROEXISTS)
+ || (vldbentry.flags & VLF_BACKEXISTS))
EnumerateEntry(&vldbentry);
}
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);
error_exit:
/* Now check if the maxvolid is larger than that stored in the VLDB */
if (maxvolid) {
- afs_int32 maxvldbid = 0;
+ afs_uint32 maxvldbid = 0;
code = ubik_VL_GetNewVolumeId(cstruct, 0, 0, &maxvldbid);
if (code) {
fprintf(STDERR,
if (!error)
error = code;
} else if (maxvolid > maxvldbid) {
- afs_int32 id, nid;
+ afs_uint32 id, nid;
id = maxvolid - maxvldbid + 1;
code = ubik_VL_GetNewVolumeId(cstruct, 0, id, &nid);
if (code) {
* 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;
- int i, j, pfail;
+ int i, pfail;
+ unsigned int j;
volEntries volumeInfo;
struct partList PartList;
afs_int32 pcnt;
afs_int32 failures = 0, modifications = 0, tentries = 0;
afs_int32 modified;
afs_uint32 maxvolid = 0;
+ char hoststr[16];
volumeInfo.volEntries_val = (volintInfo *) 0;
volumeInfo.volEntries_len = 0;
fprintf(STDOUT,
"Processing volume entry %d: %s (%lu) on server %s %s...\n",
j + 1, vi->name, (unsigned long)vi->volid,
- hostutil_GetNameByINet(aserver), pname);
+ noresolve ?
+ afs_inet_ntoa_r(aserver, hoststr) :
+ hostutil_GetNameByINet(aserver), pname);
fflush(STDOUT);
}
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++;
if (pfail) {
fprintf(STDERR,
"Could not process entries on server %s partition %s\n",
- hostutil_GetNameByINet(aserver), pname);
+ noresolve ?
+ afs_inet_ntoa_r(aserver, hoststr) :
+ hostutil_GetNameByINet(aserver), pname);
}
if (volumeInfo.volEntries_val) {
free(volumeInfo.volEntries_val);
} /* 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);
}
error_exit:
/* Now check if the maxvolid is larger than that stored in the VLDB */
if (maxvolid) {
- afs_int32 maxvldbid = 0;
+ afs_uint32 maxvldbid = 0;
code = ubik_VL_GetNewVolumeId(cstruct, 0, 0, &maxvldbid);
if (code) {
fprintf(STDERR,
if (!error)
error = code;
} else if (maxvolid > maxvldbid) {
- afs_int32 id, nid;
+ afs_uint32 id, nid;
id = maxvolid - maxvldbid + 1;
code = ubik_VL_GetNewVolumeId(cstruct, 0, id, &nid);
if (code) {
* Some error codes mean the volume is unavailable but
* still exists - so we catch these error codes.
*/
-afs_int32
-VolumeExists(afs_int32 server, afs_int32 partition, afs_int32 volumeid)
+static afs_int32
+VolumeExists(afs_uint32 server, afs_int32 partition, afs_uint32 volumeid)
{
struct rx_connection *conn = (struct rx_connection *)0;
afs_int32 code = -1;
/* CheckVldbRWBK()
*
*/
-afs_int32
+static afs_int32
CheckVldbRWBK(struct nvldbentry * entry, afs_int32 * modified)
{
int modentry = 0;
int idx;
afs_int32 code, error = 0;
char pname[10];
+ char hoststr[16];
if (modified)
*modified = 0;
idx = Lp_GetRwIndex(entry);
- /* Check to see if the RW volume exists and set the RW_EXISTS
+ /* Check to see if the RW volume exists and set the VLF_RWEXISTS
* flag accordingly.
*/
if (idx == -1) { /* Did not find a RW entry */
- if (entry->flags & RW_EXISTS) { /* ... yet entry says RW exists */
- entry->flags &= ~RW_EXISTS; /* ... so say RW does not exist */
+ if (entry->flags & VLF_RWEXISTS) { /* ... yet entry says RW exists */
+ entry->flags &= ~VLF_RWEXISTS; /* ... so say RW does not exist */
modentry++;
}
} else {
VolumeExists(entry->serverNumber[idx],
entry->serverPartition[idx], entry->volumeId[RWVOL]);
if (code == 0) { /* RW volume exists */
- if (!(entry->flags & RW_EXISTS)) { /* ... yet entry says RW does not exist */
- entry->flags |= RW_EXISTS; /* ... so say RW does exist */
+ if (!(entry->flags & VLF_RWEXISTS)) { /* ... yet entry says RW does not exist */
+ entry->flags |= VLF_RWEXISTS; /* ... so say RW does exist */
modentry++;
}
} else if (code == ENODEV) { /* RW volume does not exist */
- if (entry->flags & RW_EXISTS) { /* ... yet entry says RW exists */
- entry->flags &= ~RW_EXISTS; /* ... so say RW does not exist */
+ if (entry->flags & VLF_RWEXISTS) { /* ... yet entry says RW exists */
+ entry->flags &= ~VLF_RWEXISTS; /* ... so say RW does not exist */
modentry++;
}
} else {
/* If VLDB says it didn't exist, then ignore error */
- if (entry->flags & RW_EXISTS) {
+ if (entry->flags & VLF_RWEXISTS) {
MapPartIdIntoName(entry->serverPartition[idx], pname);
fprintf(STDERR,
"Transaction call failed for RW volume %u on server %s %s\n",
entry->volumeId[RWVOL],
- hostutil_GetNameByINet(entry->serverNumber[idx]),
+ noresolve ?
+ afs_inet_ntoa_r(entry->serverNumber[idx], hoststr) :
+ hostutil_GetNameByINet(entry->serverNumber[idx]),
pname);
ERROR_EXIT(code);
}
}
}
- /* Check to see if the BK volume exists and set the BACK_EXISTS
+ /* Check to see if the BK volume exists and set the VLF_BACKEXISTS
* flag accordingly. idx already ponts to the RW entry.
*/
if (idx == -1) { /* Did not find a RW entry */
- if (entry->flags & BACK_EXISTS) { /* ... yet entry says BK exists */
- entry->flags &= ~BACK_EXISTS; /* ... so say BK does not exist */
+ if (entry->flags & VLF_BACKEXISTS) { /* ... yet entry says BK exists */
+ entry->flags &= ~VLF_BACKEXISTS; /* ... so say BK does not exist */
modentry++;
}
} else { /* Found a RW entry */
entry->serverPartition[idx],
entry->volumeId[BACKVOL]);
if (code == 0) { /* BK volume exists */
- if (!(entry->flags & BACK_EXISTS)) { /* ... yet entry says BK does not exist */
- entry->flags |= BACK_EXISTS; /* ... so say BK does exist */
+ if (!(entry->flags & VLF_BACKEXISTS)) { /* ... yet entry says BK does not exist */
+ entry->flags |= VLF_BACKEXISTS; /* ... so say BK does exist */
modentry++;
}
} else if (code == ENODEV) { /* BK volume does not exist */
- if (entry->flags & BACK_EXISTS) { /* ... yet entry says BK exists */
- entry->flags &= ~BACK_EXISTS; /* ... so say BK does not exist */
+ if (entry->flags & VLF_BACKEXISTS) { /* ... yet entry says BK exists */
+ entry->flags &= ~VLF_BACKEXISTS; /* ... so say BK does not exist */
modentry++;
}
} else {
/* If VLDB says it didn't exist, then ignore error */
- if (entry->flags & BACK_EXISTS) {
+ if (entry->flags & VLF_BACKEXISTS) {
MapPartIdIntoName(entry->serverPartition[idx], pname);
fprintf(STDERR,
"Transaction call failed for BK volume %u on server %s %s\n",
entry->volumeId[BACKVOL],
- hostutil_GetNameByINet(entry->serverNumber[idx]),
+ noresolve ?
+ afs_inet_ntoa_r(entry->serverNumber[idx], hoststr) :
+ hostutil_GetNameByINet(entry->serverNumber[idx]),
pname);
ERROR_EXIT(code);
}
/* If there is an idx but the BK and RW volumes no
* longer exist, then remove the RW entry.
*/
- if ((idx != -1) && !(entry->flags & RW_EXISTS)
- && !(entry->flags & BACK_EXISTS)) {
+ if ((idx != -1) && !(entry->flags & VLF_RWEXISTS)
+ && !(entry->flags & VLF_BACKEXISTS)) {
Lp_SetRWValue(entry, entry->serverNumber[idx],
entry->serverPartition[idx], 0L, 0L);
entry->nServers--;
return (error);
}
-int
+static afs_int32
CheckVldbRO(struct nvldbentry *entry, afs_int32 * modified)
{
int idx;
int foundro = 0, modentry = 0;
afs_int32 code, error = 0;
char pname[10];
+ char hoststr[16];
if (modified)
*modified = 0;
- /* Check to see if the RO volumes exist and set the RO_EXISTS
- * flag accordingly.
+ /* Check to see if the RO volumes exist and set the VLF_ROEXISTS
+ * flag accordingly.
*/
for (idx = 0; idx < entry->nServers; idx++) {
- if (!(entry->serverFlags[idx] & ITSROVOL)) {
+ if (!(entry->serverFlags[idx] & VLSF_ROVOL)) {
continue; /* not a RO */
}
fprintf(STDERR,
"Transaction call failed for RO %u on server %s %s\n",
entry->volumeId[ROVOL],
- hostutil_GetNameByINet(entry->serverNumber[idx]), pname);
+ noresolve ?
+ afs_inet_ntoa_r(entry->serverNumber[idx], hoststr) :
+ hostutil_GetNameByINet(entry->serverNumber[idx]), pname);
ERROR_EXIT(code);
}
}
if (foundro) { /* A RO volume exists */
- if (!(entry->flags & RO_EXISTS)) { /* ... yet entry says RW does not exist */
- entry->flags |= RO_EXISTS; /* ... so say RW does exist */
+ if (!(entry->flags & VLF_ROEXISTS)) { /* ... yet entry says RW does not exist */
+ entry->flags |= VLF_ROEXISTS; /* ... so say RW does exist */
modentry++;
}
} else { /* A RO volume does not exist */
- if (entry->flags & RO_EXISTS) { /* ... yet entry says RO exists */
- entry->flags &= ~RO_EXISTS; /* ... so say RO does not exist */
+ if (entry->flags & VLF_ROEXISTS) { /* ... yet entry says RO exists */
+ entry->flags &= ~VLF_ROEXISTS; /* ... so say RO does not exist */
modentry++;
}
}
/* CheckVldb()
* Ensure that <entry> matches with the info on file servers
*/
-afs_int32
-CheckVldb(struct nvldbentry * entry, afs_int32 * modified)
+static afs_int32
+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 (verbose) {
fprintf(STDOUT, "_______________________________\n");
fprintf(STDOUT, "\n-- status before -- \n");
- if ((entry->flags & RW_EXISTS) || (entry->flags & RO_EXISTS)
- || (entry->flags & BACK_EXISTS))
+ if ((entry->flags & VLF_RWEXISTS) || (entry->flags & VLF_ROEXISTS)
+ || (entry->flags & VLF_BACKEXISTS))
EnumerateEntry(entry);
fprintf(STDOUT, "\n");
}
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) {
if (pass == 1)
goto retry;
- if (!(entry->flags & RW_EXISTS) && !(entry->flags & BACK_EXISTS)
- && !(entry->flags & RO_EXISTS) && doit) {
+ if (!(entry->flags & VLF_RWEXISTS) && !(entry->flags & VLF_BACKEXISTS)
+ && !(entry->flags & VLF_ROEXISTS) && doit) {
/* The RW, BK, nor RO volumes do not exist. Delete the VLDB entry */
code =
ubik_VL_DeleteEntry(cstruct, 0, entry->volumeId[RWVOL],
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 */
afs_int32 tid;
struct rx_connection *aconn;
int islocked;
+ char hoststr[16];
error = 0;
aconn = (struct rx_connection *)0;
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) {
+ if (entry->flags & VLF_RWEXISTS) {
index = Lp_GetRwIndex(entry);
if (index == -1) { /* there is a serious discrepancy */
fprintf(STDERR,
}
aconn = UV_Bind(entry->serverNumber[index], AFSCONF_VOLUMEPORT);
code =
- AFSVolTransCreate(aconn, entry->volumeId[RWVOL],
+ AFSVolTransCreate_retry(aconn, entry->volumeId[RWVOL],
entry->serverPartition[index], ITOffline, &tid);
if (code) { /*volume doesnot exist */
fprintf(STDERR,
aconn = (struct rx_connection *)0;
}
/*end rw volume processing */
- if (entry->flags & BACK_EXISTS) { /*process the backup volume */
+ if (entry->flags & VLF_BACKEXISTS) { /*process the backup volume */
index = Lp_GetRwIndex(entry);
if (index == -1) { /* there is a serious discrepancy */
fprintf(STDERR,
}
aconn = UV_Bind(entry->serverNumber[index], AFSCONF_VOLUMEPORT);
code =
- AFSVolTransCreate(aconn, entry->volumeId[BACKVOL],
+ AFSVolTransCreate_retry(aconn, entry->volumeId[BACKVOL],
entry->serverPartition[index], ITOffline, &tid);
if (code) { /*volume doesnot exist */
fprintf(STDERR,
if (aconn)
rx_DestroyConnection(aconn);
aconn = (struct rx_connection *)0;
- if (entry->flags & RO_EXISTS) { /*process the ro volumes */
+ if (entry->flags & VLF_ROEXISTS) { /*process the ro volumes */
for (i = 0; i < entry->nServers; i++) {
- if (entry->serverFlags[i] & ITSROVOL) {
+ if (entry->serverFlags[i] & VLSF_ROVOL) {
aconn = UV_Bind(entry->serverNumber[i], AFSCONF_VOLUMEPORT);
code =
- AFSVolTransCreate(aconn, entry->volumeId[ROVOL],
+ AFSVolTransCreate_retry(aconn, entry->volumeId[ROVOL],
entry->serverPartition[i], ITOffline,
&tid);
if (code) { /*volume doesnot exist */
if (!code) {
VPRINT2("Renamed RO volume %s on host %s\n",
nameBuffer,
- hostutil_GetNameByINet(entry->
+ noresolve ?
+ afs_inet_ntoa_r(entry->serverNumber[i], hoststr) :
+ hostutil_GetNameByINet(entry->
serverNumber[i]));
code = AFSVolEndTrans(aconn, tid, &rcode);
tid = 0;
/*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_int32 volid)
+UV_VolumeZap(afs_uint32 server, afs_int32 part, afs_uint32 volid)
{
- afs_int32 rcode, ttid, error, code;
+ afs_int32 error;
struct rx_connection *aconn;
- code = 0;
- error = 0;
- ttid = 0;
-
aconn = UV_Bind(server, AFSCONF_VOLUMEPORT);
- code = AFSVolTransCreate(aconn, volid, part, ITOffline, &ttid);
- if (code) {
- fprintf(STDERR, "Could not start transaction on volume %lu\n",
- (unsigned long)volid);
- error = code;
- goto zfail;
- }
- code = AFSVolDeleteVolume(aconn, ttid);
- if (code) {
- fprintf(STDERR, "Could not delete volume %lu\n",
- (unsigned long)volid);
- error = code;
- goto zfail;
- }
- code = AFSVolEndTrans(aconn, ttid, &rcode);
- ttid = 0;
- if (!code)
- code = rcode;
- if (code) {
- fprintf(STDERR, "Could not end transaction on volume %lu\n",
- (unsigned long)volid);
- error = code;
- goto zfail;
- }
- zfail:
- if (ttid) {
- code = AFSVolEndTrans(aconn, ttid, &rcode);
- if (!code)
- code = rcode;
- if (!error)
- error = code;
+ error = DoVolDelete(aconn, volid, part,
+ "the", 0, NULL, NULL);
+ if (error == VNOVOL) {
+ EPRINT1(error, "Failed to start transaction on %u\n", volid);
}
+
PrintError("", error);
if (aconn)
rx_DestroyConnection(aconn);
}
int
-UV_SetVolume(afs_int32 server, afs_int32 partition, afs_int32 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;
ERROR_EXIT(-1);
}
- code = AFSVolTransCreate(conn, volid, partition, transflag, &tid);
+ code = AFSVolTransCreate_retry(conn, volid, partition, transflag, &tid);
if (code) {
fprintf(STDERR, "SetVolumeStatus: TransCreate Failed\n");
ERROR_EXIT(code);
}
int
-UV_SetVolumeInfo(afs_int32 server, afs_int32 partition, afs_int32 volid,
+UV_SetVolumeInfo(afs_uint32 server, afs_int32 partition, afs_uint32 volid,
volintInfo * infop)
{
struct rx_connection *conn = 0;
ERROR_EXIT(-1);
}
- code = AFSVolTransCreate(conn, volid, partition, ITOffline, &tid);
+ code = AFSVolTransCreate_retry(conn, volid, partition, ITOffline, &tid);
if (code) {
fprintf(STDERR, "SetVolumeInfo: TransCreate Failed\n");
ERROR_EXIT(code);
}
int
-UV_GetSize(afs_int32 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;
aconn = UV_Bind(afromserver, AFSCONF_VOLUMEPORT);
VPRINT1("Starting transaction on volume %u...", afromvol);
- code = AFSVolTransCreate(aconn, afromvol, afrompart, ITBusy, &tid);
+ code = AFSVolTransCreate_retry(aconn, afromvol, afrompart, ITBusy, &tid);
EGOTO1(error_exit, code,
"Could not start transaction on the volume %u to be measured\n",
afromvol);
{
int i, count;
+ memset(new, 0, sizeof(struct nvldbentry));
+
/*copy all the fields */
strcpy(new->name, old->name);
/* new->volumeType = old->volumeType;*/
git://git.openafs.org / openafs.git / blobdiff