int verbose = 0, noresolve = 0;
struct release {
- afs_int32 crtime;
- afs_int32 uptime;
+ afs_uint32 crtime;
+ afs_uint32 uptime;
afs_int32 vldbEntryIndex;
};
/* Protos for static routines */
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 apart, afs_uint32 okvol,
+ afs_uint32 delvol);
+static int DelVol(struct rx_connection *conn, afs_uint32 vid, afs_int32 part,
afs_int32 flags);
static int GetTrans(struct nvldbentry *vldbEntryPtr, afs_int32 index,
struct rx_connection **connPtr, afs_int32 * transPtr,
return tc;
}
+static int
+AFSVolCreateVolume_retry(struct rx_connection *z_conn,
+ afs_int32 partition, char *name, afs_int32 type,
+ afs_int32 parent, afs_int32 *volid, afs_int32 *trans)
+{
+ afs_int32 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 <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);
/* forcibly remove a volume. Very dangerous call */
int
-UV_NukeVolume(afs_int32 server, afs_int32 partid, afs_int32 volid)
+UV_NukeVolume(afs_int32 server, afs_int32 partid, afs_uint32 volid)
{
register struct rx_connection *tconn;
register afs_int32 code;
/* old interface to create volume */
int
UV_CreateVolume(afs_int32 aserver, afs_int32 apart, char *aname,
- afs_int32 * anewid)
+ afs_uint32 * anewid)
{
afs_int32 code;
code = UV_CreateVolume2(aserver, apart, aname, 5000, 0, 0, 0, 0, anewid);
int
UV_CreateVolume2(afs_int32 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)
{
-
register struct rx_connection *aconn;
afs_int32 tid;
register afs_int32 code;
/* 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);
-
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);
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)
+ afs_uint32 aid)
{
register struct rx_connection *aconn;
afs_int32 error;
* becomes zero
*/
int
-UV_DeleteVolume(afs_int32 aserver, afs_int32 apart, afs_int32 avolid)
+UV_DeleteVolume(afs_int32 aserver, afs_int32 apart, afs_uint32 avolid)
{
struct rx_connection *aconn = (struct rx_connection *)0;
afs_int32 ttid = 0;
/* 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 = AFSVolTransCreate_retry(aconn, avolid, apart, ITOffline, &ttid);
if (code) {
if (code == VNOVOL) {
notondisk = 1;
/* Delete backup if it exists */
code =
- AFSVolTransCreate(aconn, entry.volumeId[BACKVOL], apart,
- ITOffline, &ttid);
+ AFSVolTransCreate_retry(aconn, entry.volumeId[BACKVOL], apart,
+ ITOffline, &ttid);
+
if (!code) {
if (verbose) {
fprintf(STDOUT, "Trying to delete the backup volume %u ...",
*/
int
-UV_MoveVolume2(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
+UV_MoveVolume2(afs_uint32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
afs_int32 atoserver, afs_int32 atopart, int flags)
{
struct rx_connection *toconn, *fromconn;
afs_int32 fromDate;
struct restoreCookie cookie;
register afs_int32 vcode, code;
- afs_int32 newVol, volid, backupId;
+ afs_uint32 newVol, volid, backupId;
struct volser_status tstatus;
struct destServer destination;
pntg = 1;
code =
- AFSVolTransCreate(fromconn, afromvol, afrompart, ITOffline,
- &fromtid);
+ AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITOffline,
+ &fromtid);
+
if (!code) { /* volume exists - delete it */
VPRINT1("Setting flags on leftover source volume %u ...",
afromvol);
/*delete the backup volume now */
fromtid = 0;
code =
- AFSVolTransCreate(fromconn, backupId, afrompart, ITOffline,
- &fromtid);
+ AFSVolTransCreate_retry(fromconn, backupId, afrompart, ITOffline,
+ &fromtid);
+
if (!code) { /* backup volume exists - delete it */
VPRINT1("Setting flags on leftover backup volume %u ...",
backupId);
* ***/
VPRINT1("Starting transaction on source volume %u ...", afromvol);
- code = AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy, &fromtid);
+ code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy, &fromtid);
EGOTO1(mfail, code, "Failed to create transaction on the volume %u\n",
afromvol);
VDONE;
/* All of this is to get the fromDate */
VPRINT1("Starting transaction on the cloned volume %u ...", newVol);
code =
- AFSVolTransCreate(fromconn, newVol, afrompart, ITOffline,
+ AFSVolTransCreate_retry(fromconn, newVol, afrompart, ITOffline,
&clonetid);
EGOTO1(mfail, code,
"Failed to start a transaction on the cloned volume%u\n",
/* create a volume on the target machine */
volid = afromvol;
- code = AFSVolTransCreate(toconn, volid, atopart, ITOffline, &totid);
+ code = AFSVolTransCreate_retry(toconn, volid, atopart, ITOffline, &totid);
if (!code) {
/* Delete the existing volume.
* While we are deleting the volume in these steps, the transaction
* ***/
VPRINT1("Starting transaction on source volume %u ...", afromvol);
- code = AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy, &fromtid);
+ code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy, &fromtid);
EGOTO1(mfail, code,
"Failed to create a transaction on the source volume %u\n",
afromvol);
VPRINT1("Creating transaction for backup volume %u on source ...",
backupId);
code =
- AFSVolTransCreate(fromconn, backupId, afrompart, ITOffline, &fromtid);
+ AFSVolTransCreate_retry(fromconn, backupId, afrompart, ITOffline, &fromtid);
VDONE;
if (!code) {
VPRINT1("Setting flags on backup volume %u on source ...", backupId);
if (!(flags & RV_NOCLONE)) {
VPRINT1("Starting transaction on the cloned volume %u ...", newVol);
code =
- AFSVolTransCreate(fromconn, newVol, afrompart, ITOffline,
+ AFSVolTransCreate_retry(fromconn, newVol, afrompart, ITOffline,
&clonetid);
EGOTO1(mfail, code,
"Failed to start a transaction on the cloned volume%u\n",
ubik_VL_ReleaseLock(cstruct, 0, afromvol, -1,
(LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
VDONE;
+ islocked = 0;
}
if (clonetid) {
("Recovery: Creating transaction for destination volume %u ...",
volid);
code =
- AFSVolTransCreate(toconn, volid, atopart, ITOffline, &totid);
+ AFSVolTransCreate_retry(toconn, volid, atopart, ITOffline, &totid);
if (!code) {
VDONE;
VPRINT1("Recovery: Creating transaction on source volume %u ...",
afromvol);
code =
- AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy,
+ AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy,
&fromtid);
if (!code) {
VDONE;
VPRINT1("Recovery: Creating transaction on backup volume %u ...",
backupId);
code =
- AFSVolTransCreate(fromconn, backupId, afrompart, ITOffline,
+ AFSVolTransCreate_retry(fromconn, backupId, afrompart, ITOffline,
&fromtid);
if (!code) {
VDONE;
VPRINT1("Recovery: Creating transaction on source volume %u ...",
afromvol);
code =
- AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy,
+ AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy,
&fromtid);
if (!code) {
VDONE;
VPRINT1("Recovery: Creating transaction on clone volume %u ...",
newVol);
code =
- AFSVolTransCreate(fromconn, newVol, afrompart, ITOffline,
+ AFSVolTransCreate_retry(fromconn, newVol, afrompart, ITOffline,
&clonetid);
if (!code) {
VDONE;
}
/* 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;
+ islocked = 0;
+ }
done: /* routine cleanup */
if (volName)
free(volName);
int
-UV_MoveVolume(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
+UV_MoveVolume(afs_uint32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
afs_int32 atoserver, afs_int32 atopart)
{
return UV_MoveVolume2(afromvol, afromserver, afrompart,
* RV_NOCLONE - don't use a copy clone
*/
int
-UV_CopyVolume2(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
+UV_CopyVolume2(afs_uint32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
char *atovolname, afs_int32 atoserver, afs_int32 atopart,
- afs_int32 atovolid, int flags)
+ afs_uint32 atovolid, int flags)
{
struct rx_connection *toconn, *fromconn;
afs_int32 fromtid, totid, clonetid;
afs_int32 fromDate, cloneFromDate;
struct restoreCookie cookie;
register afs_int32 vcode, code;
- afs_int32 cloneVol, newVol, volflag;
+ afs_uint32 cloneVol, newVol;
+ afs_int32 volflag;
struct volser_status tstatus;
struct destServer destination;
cloneVol = 0;
if (!(flags & RV_NOCLONE)) {
VPRINT1("Starting transaction on source volume %u ...", afromvol);
- code = AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy,
+ code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy,
&fromtid);
EGOTO1(mfail, code, "Failed to create transaction on the volume %u\n",
afromvol);
if (!(flags & RV_NOCLONE)) {
VPRINT1("Starting transaction on the cloned volume %u ...", cloneVol);
code =
- AFSVolTransCreate(fromconn, cloneVol, afrompart, ITOffline,
+ AFSVolTransCreate_retry(fromconn, cloneVol, afrompart, ITOffline,
&clonetid);
EGOTO1(mfail, code,
"Failed to start a transaction on the cloned volume%u\n",
/* create a volume on the target machine */
cloneFromDate = 0;
- code = AFSVolTransCreate(toconn, newVol, atopart, ITOffline, &totid);
+ code = AFSVolTransCreate_retry(toconn, newVol, atopart, ITOffline, &totid);
if (!code) {
if ((flags & RV_CPINCR)) {
VPRINT1("Getting status of pre-existing volume %u ...", newVol);
* ***/
VPRINT1("Starting transaction on source volume %u ...", afromvol);
- code = AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy, &fromtid);
+ code = AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy, &fromtid);
EGOTO1(mfail, code,
"Failed to create a transaction on the source volume %u\n",
afromvol);
if (!(flags & RV_NOCLONE)) {
VPRINT1("Starting transaction on the cloned volume %u ...", cloneVol);
code =
- AFSVolTransCreate(fromconn, cloneVol, afrompart, ITOffline,
+ AFSVolTransCreate_retry(fromconn, cloneVol, afrompart, ITOffline,
&clonetid);
EGOTO1(mfail, code,
"Failed to start a transaction on the cloned volume%u\n",
VPRINT1("Recovery: Creating transaction on clone volume %u ...",
cloneVol);
code =
- AFSVolTransCreate(fromconn, cloneVol, afrompart, ITOffline,
+ AFSVolTransCreate_retry(fromconn, cloneVol, afrompart, ITOffline,
&clonetid);
if (!code) {
VDONE;
int
-UV_CopyVolume(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
+UV_CopyVolume(afs_uint32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
char *atovolname, afs_int32 atoserver, afs_int32 atopart)
{
return UV_CopyVolume2(afromvol, afromserver, afrompart,
*/
int
-UV_BackupVolume(afs_int32 aserver, afs_int32 apart, afs_int32 avolid)
+UV_BackupVolume(afs_int32 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;
/* 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);
+ code = AFSVolTransCreate_retry(aconn, backupID, apart, ITOffline, &btid);
if (code) {
if (code != VNOVOL) {
fprintf(STDERR, "Could not reach the backup volume %lu\n",
/* 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 = AFSVolTransCreate_retry(aconn, avolid, apart, ITBusy, &ttid);
if (code) {
fprintf(STDERR, "Could not start a transaction on the volume %lu\n",
(unsigned long)avolid);
}
/* 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",
*/
int
-UV_CloneVolume(afs_int32 aserver, afs_int32 apart, afs_int32 avolid,
- afs_int32 acloneid, char *aname, int flags)
+UV_CloneVolume(afs_int32 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;
* 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);
+ code = AFSVolTransCreate_retry(aconn, acloneid, apart, ITOffline, &btid);
if (code) {
if (code != VNOVOL) {
fprintf(STDERR, "Could not reach the clone volume %lu\n",
/* 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 = AFSVolTransCreate_retry(aconn, avolid, apart, ITBusy, &ttid);
if (code) {
fprintf(STDERR, "Could not start a transaction on the volume %lu\n",
(unsigned long)avolid);
/* 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",
}
static int
-DelVol(struct rx_connection *conn, afs_int32 vid, afs_int32 part,
+DelVol(struct rx_connection *conn, afs_uint32 vid, afs_int32 part,
afs_int32 flags)
{
afs_int32 acode, ccode, rcode, tid;
ccode = rcode = tid = 0;
- acode = AFSVolTransCreate(conn, vid, part, flags, &tid);
+ acode = AFSVolTransCreate_retry(conn, vid, part, flags, &tid);
if (!acode) { /* It really was there */
acode = AFSVolDeleteVolume(conn, tid);
if (acode) {
struct rx_connection **connPtr, afs_int32 * transPtr,
afs_int32 * crtimePtr, afs_int32 * uptimePtr)
{
- 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;
volid = vldbEntryPtr->volumeId[ROVOL];
if (volid)
code =
- AFSVolTransCreate(*connPtr, volid,
+ AFSVolTransCreate_retry(*connPtr, volid,
vldbEntryPtr->serverPartition[index], ITOffline,
transPtr);
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] =
*/
int
-UV_ReleaseVolume(afs_int32 afromvol, afs_int32 afromserver,
+UV_ReleaseVolume(afs_uint32 afromvol, afs_int32 afromserver,
afs_int32 afrompart, int forceflag)
{
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, roVolId;
struct replica *replicas = 0;
struct nvldbentry entry, storeEntry;
int i, volcount, m, fullrelease, vldbindex;
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;
+ afs_uint32 rwupdate, clcrdate;
struct rtime {
int validtime;
afs_uint32 uptime;
fullrelease = 1; /* Do a full 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,
"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,
/* Begin transaction on RW and mark it busy while we clone it */
code =
- AFSVolTransCreate(fromconn, afromvol, afrompart, ITBusy,
+ AFSVolTransCreate_retry(fromconn, afromvol, afrompart, ITBusy,
&clonetid);
ONERROR(code, afromvol, "Failed to start transaction on volume %u\n");
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");
/* Create a transaction on the cloned volume */
VPRINT1("Starting transaction on cloned volume %u...", cloneVolId);
code =
- AFSVolTransCreate(fromconn, cloneVolId, afrompart, ITBusy, &fromtid);
+ AFSVolTransCreate_retry(fromconn, cloneVolId, afrompart, ITBusy, &fromtid);
if (!fullrelease && code)
ONERROR(VOLSERNOVOL, afromvol,
"Old clone is inaccessible. Try vos release -f %u.\n");
* extracting parameters from the rock
*/
int
-UV_DumpVolume(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
+UV_DumpVolume(afs_uint32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
afs_int32 fromdate, afs_int32(*DumpFunction) (), char *rock,
afs_int32 flags)
{
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);
* extracting parameters from the rock
*/
int
-UV_DumpClonedVolume(afs_int32 afromvol, afs_int32 afromserver,
+UV_DumpClonedVolume(afs_uint32 afromvol, afs_int32 afromserver,
afs_int32 afrompart, afs_int32 fromdate,
afs_int32(*DumpFunction) (), char *rock, afs_int32 flags)
{
afs_int32 fromtid = 0, rxError = 0, rcode = 0;
afs_int32 clonetid = 0;
afs_int32 code = 0, vcode = 0, error = 0;
- afs_int32 clonevol = 0;
+ afs_uint32 clonevol = 0;
char vname[64];
time_t tmv = fromdate;
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);
VEPRINT1("Starting transaction on the cloned volume %u ...", clonevol);
code =
- AFSVolTransCreate(fromconn, clonevol, afrompart, ITOffline,
+ AFSVolTransCreate_retry(fromconn, clonevol, afrompart, ITOffline,
&clonetid);
EGOTO1(error_exit, code,
"Failed to start a transaction on the cloned volume%u\n",
* after extracting params from the rock
*/
int
-UV_RestoreVolume2(afs_int32 toserver, afs_int32 topart, afs_int32 tovolid,
+UV_RestoreVolume2(afs_int32 toserver, afs_int32 topart, afs_uint32 tovolid,
afs_int32 toparentid, char tovolname[], int flags,
afs_int32(*WriteData) (), char *rock)
{
struct volintInfo vinfo;
char partName[10];
char tovolreal[VOLSER_OLDMAXVOLNAME];
- afs_int32 pvolid, pparentid;
- afs_int32 temptid;
+ afs_uint32 pvolid;
+ afs_int32 temptid, pparentid;
int success;
struct nvldbentry entry, storeEntry;
afs_int32 error;
VPRINT1("Deleting the previous volume %u ...", pvolid);
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 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);
hostutil_GetNameByINet(entry.serverNumber[index]),
apartName);
code =
- AFSVolTransCreate(tempconn, pvolid,
+ AFSVolTransCreate_retry(tempconn, pvolid,
entry.serverPartition[index],
ITOffline, &temptid);
if (!code) {
}
int
-UV_RestoreVolume(afs_int32 toserver, afs_int32 topart, afs_int32 tovolid,
+UV_RestoreVolume(afs_int32 toserver, afs_int32 topart, afs_uint32 tovolid,
char tovolname[], int flags, afs_int32(*WriteData) (),
char *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");
/*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_AddSite(afs_int32 server, afs_int32 part, afs_uint32 volid, afs_int32 valid)
{
int j, nro = 0, islocked = 0;
struct nvldbentry entry, storeEntry;
/*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_int32 server, afs_int32 part, afs_uint32 volid)
{
afs_int32 vcode;
struct nvldbentry entry, storeEntry;
/*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_int32 server, afs_int32 part, afs_uint32 volid)
{
afs_int32 vcode;
struct nvldbentry entry, storeEntry;
curPtr->volFlags &= ~CLONEZAPPED;
success = 1;
code =
- AFSVolTransCreate(aconn, curPtr->volCloneId, apart, ITOffline,
+ AFSVolTransCreate_retry(aconn, curPtr->volCloneId, apart, ITOffline,
&tid);
if (code)
success = 0;
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;
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,
/* 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_int32 aserver, afs_int32 apart, afs_uint32 volid,
struct volintInfo **resultPtr)
{
struct rx_connection *aconn;
*------------------------------------------------------------------------*/
int
-UV_XListOneVolume(afs_int32 a_serverID, afs_int32 a_partID, afs_int32 a_volID,
+UV_XListOneVolume(afs_int32 a_serverID, afs_int32 a_partID, afs_uint32 a_volID,
struct volintXInfo **a_resultPP)
{
struct rx_connection *rxConnP; /*Rx connection to Volume Server */
CheckVolume(volintInfo * volumeinfo, afs_int32 aserver, afs_int32 apart,
afs_int32 * modentry, afs_uint32 * maxvolid)
{
- 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;
+ afs_uint32 rwvolid;
char hoststr[16];
if (modentry) {
entry.serverNumber[idx] = aserver;
entry.serverPartition[idx] = apart;
- entry.serverFlags[idx] = ITSRWVOL;
+ entry.serverFlags[idx] = ITSBACKVOL;
modified++;
}
{
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);
{
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;
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_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)
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)) {
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) {
{
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;
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) {
* still exists - so we catch these error codes.
*/
afs_int32
-VolumeExists(afs_int32 server, afs_int32 partition, afs_int32 volumeid)
+VolumeExists(afs_int32 server, afs_int32 partition, afs_uint32 volumeid)
{
struct rx_connection *conn = (struct rx_connection *)0;
afs_int32 code = -1;
}
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 = 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 (entry->serverFlags[i] & ITSROVOL) {
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 */
/*delete the volume without interacting with the vldb */
int
-UV_VolumeZap(afs_int32 server, afs_int32 part, afs_int32 volid)
+UV_VolumeZap(afs_int32 server, afs_int32 part, afs_uint32 volid)
{
afs_int32 rcode, ttid, error, code;
struct rx_connection *aconn;
ttid = 0;
aconn = UV_Bind(server, AFSCONF_VOLUMEPORT);
- code = AFSVolTransCreate(aconn, volid, part, ITOffline, &ttid);
+ code = AFSVolTransCreate_retry(aconn, volid, part, ITOffline, &ttid);
if (code) {
fprintf(STDERR, "Could not start transaction on volume %lu\n",
(unsigned long)volid);
}
int
-UV_SetVolume(afs_int32 server, afs_int32 partition, afs_int32 volid,
+UV_SetVolume(afs_int32 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_int32 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_int32 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);