kill-more-ubikcall-20070719

tested more ubik call death, so, byebye

diff --git a/src/volser/vos.c b/src/volser/vos.c
index 7980e72..d02e512 100644 (file)
--- a/src/volser/vos.c
+++ b/src/volser/vos.c
@@ -4188,7 +4188,7 @@ DeleteEntry(as)
                fflush(STDOUT);
                continue;
            }
-           vcode = ubik_Call(VL_DeleteEntry, cstruct, 0, avolid, RWVOL);
+           vcode = ubik_VL_DeleteEntry(cstruct, 0, avolid, RWVOL);
            if (vcode) {
                fprintf(STDERR, "Could not delete entry for volume %s\n",
                        itp->data);
@@ -4301,7 +4301,7 @@ DeleteEntry(as)
 
        /* Only matches the RW volume name */
        avolid = vllist->volumeId[RWVOL];
-       vcode = ubik_Call(VL_DeleteEntry, cstruct, 0, avolid, RWVOL);
+       vcode = ubik_VL_DeleteEntry(cstruct, 0, avolid, RWVOL);
        if (vcode) {
            fprintf(STDOUT, "Could not delete VDLB entry for  %s\n",
                    vllist->name);
@@ -4936,8 +4936,9 @@ UnlockVLDB(as)
        vllist = &arrayEntries.nbulkentries_val[j];
        volid = vllist->volumeId[RWVOL];
        vcode =
-           ubik_Call(VL_ReleaseLock, cstruct, 0, volid, -1,
-                     LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
+           ubik_VL_ReleaseLock(cstruct, 0, volid, -1,
+                               LOCKREL_OPCODE | LOCKREL_AFSID | 
+                               LOCKREL_TIMESTAMP);
        if (vcode) {
            fprintf(STDERR, "Could not unlock entry for volume %s\n",
                    vllist->name);
@@ -5191,8 +5192,8 @@ print_addrs(const bulkaddrs * addrs, const afsUUID * m_uuid, int nentries,
                m_addrs.bulkaddrs_val = 0;
                m_addrs.bulkaddrs_len = 0;
                vcode =
-                   ubik_Call(VL_GetAddrsU, cstruct, 0, &m_attrs, &m_uuid,
-                             &vlcb, &m_nentries, &m_addrs);
+                   ubik_VL_GetAddrsU(cstruct, 0, &m_attrs, &m_uuid,
+                                     &vlcb, &m_nentries, &m_addrs);
                if (vcode) {
                    fprintf(STDERR,
                            "vos: could not list the multi-homed server addresses\n");
@@ -5362,7 +5363,7 @@ LockEntry(as)
                    as->parms[0].items->data);
        exit(1);
     }
-    vcode = ubik_Call(VL_SetLock, cstruct, 0, avolid, -1, VLOP_DELETE);
+    vcode = ubik_VL_SetLock(cstruct, 0, avolid, -1, VLOP_DELETE);
     if (vcode) {
        fprintf(STDERR, "Could not lock VLDB entry for volume %s\n",
                as->parms[0].items->data);
@@ -5490,7 +5491,7 @@ ConvertRO(as)
     }
 
     vcode =
-       ubik_Call(VL_SetLock, cstruct, 0, entry.volumeId[RWVOL], RWVOL,
+       ubik_VL_SetLock(cstruct, 0, entry.volumeId[RWVOL], RWVOL,
                  VLOP_MOVE);
     aconn = UV_Bind(server, AFSCONF_VOLUMEPORT);
     code = AFSVolConvertROtoRWvolume(aconn, partition, volid);

diff --git a/src/volser/vsprocs.c b/src/volser/vsprocs.c
index 6f97b88..f2521ee 100644 (file)
--- a/src/volser/vsprocs.c
+++ b/src/volser/vsprocs.c
@@ -643,7 +643,7 @@ UV_CreateVolume2(afs_int32 aserver, afs_int32 apart, char *aname,
 
     aconn = UV_Bind(aserver, AFSCONF_VOLUMEPORT);
     /* next the next 3 available ids from the VLDB */
-    vcode = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 3, anewid);
+    vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 3, anewid);
     EGOTO1(cfail, vcode, "Could not get an Id for volume %s\n", aname);
 
     code =
@@ -787,7 +787,7 @@ UV_DeleteVolume(afs_int32 aserver, afs_int32 apart, afs_int32 avolid)
     int notondisk = 0, notinvldb = 0;
 
     /* Find and read bhe VLDB entry for this volume */
-    code = ubik_Call(VL_SetLock, cstruct, 0, avolid, avoltype, VLOP_DELETE);
+    code = ubik_VL_SetLock(cstruct, 0, avolid, avoltype, VLOP_DELETE);
     if (code) {
        if (code != VL_NOENT) {
            EGOTO1(error_exit, code,
@@ -937,7 +937,7 @@ UV_DeleteVolume(afs_int32 aserver, afs_int32 apart, afs_int32 avolid)
            fprintf(STDOUT,
                    "Last reference to the VLDB entry for %lu - deleting entry\n",
                    (unsigned long)avolid);
-       code = ubik_Call(VL_DeleteEntry, cstruct, 0, avolid, vtype);
+       code = ubik_VL_DeleteEntry(cstruct, 0, avolid, vtype);
        EGOTO1(error_exit, code,
               "Could not delete the VLDB entry for the volume %u \n",
               avolid);
@@ -986,8 +986,9 @@ UV_DeleteVolume(afs_int32 aserver, afs_int32 apart, afs_int32 avolid)
 
     if (islocked) {
        code =
-           ubik_Call(VL_ReleaseLock, cstruct, 0, avolid, -1,
-                     (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
+           ubik_VL_ReleaseLock(cstruct, 0, avolid, -1,
+                               (LOCKREL_OPCODE | LOCKREL_AFSID | 
+                                LOCKREL_TIMESTAMP));
        if (code) {
            EPRINT1(code,
                    "Could not release the lock on the VLDB entry for the volume %u \n",
@@ -1108,7 +1109,7 @@ UV_MoveVolume2(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
        exit(1);
     }
 
-    vcode = ubik_Call(VL_SetLock, cstruct, 0, afromvol, RWVOL, VLOP_MOVE);
+    vcode = ubik_VL_SetLock(cstruct, 0, afromvol, RWVOL, VLOP_MOVE);
     EGOTO1(mfail, vcode, "Could not lock entry for volume %u \n", afromvol);
     islocked = 1;
 
@@ -1137,7 +1138,7 @@ UV_MoveVolume2(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
                }
            }
            vcode =
-               ubik_Call(VL_ReleaseLock, cstruct, 0, afromvol, -1,
+               ubik_VL_ReleaseLock(cstruct, 0, afromvol, -1,
                          (LOCKREL_OPCODE | LOCKREL_AFSID |
                           LOCKREL_TIMESTAMP));
            EGOTO1(mfail, vcode,
@@ -1265,7 +1266,7 @@ UV_MoveVolume2(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
        VPRINT1("Allocating new volume id for clone of volume %u ...",
                afromvol);
        newVol = 0;
-       vcode = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 1, &newVol);
+       vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &newVol);
        EGOTO1(mfail, vcode,
               "Could not get an ID for the clone of volume %u from the VLDB\n",
               afromvol);
@@ -1683,7 +1684,7 @@ UV_MoveVolume2(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
     if (islocked) {
        VPRINT1("Cleanup: Releasing VLDB lock on volume %u ...", afromvol);
        vcode =
-           ubik_Call(VL_ReleaseLock, cstruct, 0, afromvol, -1,
+           ubik_VL_ReleaseLock(cstruct, 0, afromvol, -1,
                      (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
        if (vcode) {
            VPRINT("\n");
@@ -1765,7 +1766,7 @@ UV_MoveVolume2(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
     /* unlock VLDB entry */
     if (islocked) {
        VPRINT1("Recovery: Releasing VLDB lock on volume %u ...", afromvol);
-       ubik_Call(VL_ReleaseLock, cstruct, 0, afromvol, -1,
+       ubik_VL_ReleaseLock(cstruct, 0, afromvol, -1,
                  (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
        VDONE;
     }
@@ -1975,7 +1976,7 @@ UV_MoveVolume2(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
     /* unlock VLDB entry */
     VPRINT1("Recovery: Releasing lock on VLDB entry for volume %u ...",
            afromvol);
-    ubik_Call(VL_ReleaseLock, cstruct, 0, afromvol, -1,
+    ubik_VL_ReleaseLock(cstruct, 0, afromvol, -1,
              (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
     VDONE;
 
@@ -2089,7 +2090,7 @@ UV_CopyVolume2(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
        VPRINT1("Allocating new volume id for clone of volume %u ...",
                afromvol);
        cloneVol = 0;
-       vcode = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 1, &cloneVol);
+       vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &cloneVol);
        EGOTO1(mfail, vcode,
           "Could not get an ID for the clone of volume %u from the VLDB\n",
           afromvol);
@@ -2102,7 +2103,7 @@ UV_CopyVolume2(afs_int32 afromvol, afs_int32 afromserver, afs_int32 afrompart,
        /* Get a new volume id */
        VPRINT1("Allocating new volume id for copy of volume %u ...", afromvol);
        newVol = 0;
-       vcode = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 1, &newVol);
+       vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &newVol);
        EGOTO1(mfail, vcode,
               "Could not get an ID for the copy of volume %u from the VLDB\n",
               afromvol);
@@ -2560,7 +2561,7 @@ UV_BackupVolume(afs_int32 aserver, afs_int32 apart, afs_int32 avolid)
        (entry.flags & VLOP_ALLOPERS) ||        /* vldb lock already held */
        (entry.volumeId[BACKVOL] == INVALID_BID)) {     /* no assigned backup volume id */
 
-       code = ubik_Call(VL_SetLock, cstruct, 0, avolid, RWVOL, VLOP_BACKUP);
+       code = ubik_VL_SetLock(cstruct, 0, avolid, RWVOL, VLOP_BACKUP);
        if (code) {
            fprintf(STDERR,
                    "Could not lock the VLDB entry for the volume %lu\n",
@@ -2594,7 +2595,7 @@ UV_BackupVolume(afs_int32 aserver, afs_int32 apart, afs_int32 avolid)
        /* Get a backup volume id from the VLDB and update the vldb
         * entry with it. 
         */
-       code = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 1, &backupID);
+       code = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &backupID);
        if (code) {
            fprintf(STDERR,
                    "Could not allocate ID for the backup volume of  %lu from the VLDB\n",
@@ -2758,7 +2759,7 @@ UV_BackupVolume(afs_int32 aserver, afs_int32 apart, afs_int32 avolid)
            }
        } else {
            code =
-               ubik_Call(VL_ReleaseLock, cstruct, 0, avolid, RWVOL,
+               ubik_VL_ReleaseLock(cstruct, 0, avolid, RWVOL,
                          (LOCKREL_OPCODE | LOCKREL_AFSID |
                           LOCKREL_TIMESTAMP));
            if (code) {
@@ -2825,7 +2826,7 @@ UV_CloneVolume(afs_int32 aserver, afs_int32 apart, afs_int32 avolid,
        /* Get a clone id */
        VPRINT1("Allocating new volume id for clone of volume %u ...",
                avolid);
-       code = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 1, &acloneid);
+       code = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &acloneid);
        EGOTO1(bfail, code,
           "Could not get an ID for the clone of volume %u from the VLDB\n",
           avolid);
@@ -3174,7 +3175,7 @@ UV_ReleaseVolume(afs_int32 afromvol, afs_int32 afromserver,
     memset((char *)remembertime, 0, sizeof(remembertime));
     memset((char *)&results, 0, sizeof(results));
 
-    vcode = ubik_Call(VL_SetLock, cstruct, 0, afromvol, RWVOL, VLOP_RELEASE);
+    vcode = ubik_VL_SetLock(cstruct, 0, afromvol, RWVOL, VLOP_RELEASE);
     if (vcode != VL_RERELEASE)
        ONERROR(vcode, afromvol,
                "Could not lock the VLDB entry for the volume %u.\n");
@@ -3216,7 +3217,7 @@ UV_ReleaseVolume(afs_int32 afromvol, afs_int32 afromserver,
     /* Make sure we have a RO volume id to work with */
     if (entry.volumeId[ROVOL] == INVALID_BID) {
        /* need to get a new RO volume id */
-       vcode = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 1, &roVolId);
+       vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &roVolId);
        ONERROR(vcode, entry.name, "Cant allocate ID for RO volume of %s\n");
 
        entry.volumeId[ROVOL] = roVolId;
@@ -3793,7 +3794,7 @@ UV_ReleaseVolume(afs_int32 afromvol, afs_int32 afromserver,
     }
     if (islocked) {
        vcode =
-           ubik_Call(VL_ReleaseLock, cstruct, 0, afromvol, RWVOL,
+           ubik_VL_ReleaseLock(cstruct, 0, afromvol, RWVOL,
                      LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
        if (vcode) {
            fprintf(STDERR,
@@ -3951,7 +3952,7 @@ UV_DumpClonedVolume(afs_int32 afromvol, afs_int32 afromserver,
 
     /* Get a clone id */
     VPRINT1("Allocating new volume id for clone of volume %u ...", afromvol);
-    code = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 1, &clonevol);
+    code = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &clonevol);
     EGOTO1(error_exit, code,
           "Could not get an ID for the clone of volume %u from the VLDB\n",
           afromvol);
@@ -4102,7 +4103,7 @@ UV_RestoreVolume2(afs_int32 toserver, afs_int32 topart, afs_int32 tovolid,
     if (pvolid == 0) {         /*alot a new id if needed */
        vcode = VLDB_GetEntryByName(tovolname, &entry);
        if (vcode == VL_NOENT) {
-           vcode = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 1, &pvolid);
+           vcode = ubik_VL_GetNewVolumeId(cstruct, 0, 1, &pvolid);
            if (vcode) {
                fprintf(STDERR, "Could not get an Id for the volume %s\n",
                        tovolname);
@@ -4352,7 +4353,7 @@ UV_RestoreVolume2(afs_int32 toserver, afs_int32 topart, afs_int32 tovolid,
                fprintf(STDOUT, "------- New entry -------\n");
            }
            vcode =
-               ubik_Call(VL_SetLock, cstruct, 0, pvolid, voltype,
+               ubik_VL_SetLock(cstruct, 0, pvolid, voltype,
                          VLOP_RESTORE);
            if (vcode) {
                fprintf(STDERR,
@@ -4472,7 +4473,7 @@ UV_RestoreVolume2(afs_int32 toserver, afs_int32 topart, afs_int32 tovolid,
     }
     if (islocked) {
        vcode =
-           ubik_Call(VL_ReleaseLock, cstruct, 0, pvolid, voltype,
+           ubik_VL_ReleaseLock(cstruct, 0, pvolid, voltype,
                      LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
        if (vcode) {
            fprintf(STDERR,
@@ -4532,7 +4533,7 @@ UV_LockRelease(afs_int32 volid)
 
     VPRINT("Binding to the VLDB server\n");
     vcode =
-       ubik_Call(VL_ReleaseLock, cstruct, 0, volid, -1,
+       ubik_VL_ReleaseLock(cstruct, 0, volid, -1,
                  LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
     if (vcode) {
        fprintf(STDERR,
@@ -4556,7 +4557,7 @@ UV_AddSite(afs_int32 server, afs_int32 part, afs_int32 volid)
     afs_int32 vcode, error = 0;
     char apartName[10];
 
-    error = ubik_Call(VL_SetLock, cstruct, 0, volid, RWVOL, VLOP_ADDSITE);
+    error = ubik_VL_SetLock(cstruct, 0, volid, RWVOL, VLOP_ADDSITE);
     if (error) {
        fprintf(STDERR,
                " Could not lock the VLDB entry for the volume %lu \n",
@@ -4640,7 +4641,7 @@ UV_AddSite(afs_int32 server, afs_int32 part, afs_int32 volid)
   asfail:
     if (islocked) {
        vcode =
-           ubik_Call(VL_ReleaseLock, cstruct, 0, volid, RWVOL,
+           ubik_VL_ReleaseLock(cstruct, 0, volid, RWVOL,
                      LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
        if (vcode) {
            fprintf(STDERR,
@@ -4662,7 +4663,7 @@ UV_RemoveSite(afs_int32 server, afs_int32 part, afs_int32 volid)
     struct nvldbentry entry, storeEntry;
     int islocked;
 
-    vcode = ubik_Call(VL_SetLock, cstruct, 0, volid, RWVOL, VLOP_ADDSITE);
+    vcode = ubik_VL_SetLock(cstruct, 0, volid, RWVOL, VLOP_ADDSITE);
     if (vcode) {
        fprintf(STDERR, " Could not lock the VLDB entry for volume %lu \n",
                (unsigned long)volid);
@@ -4683,13 +4684,13 @@ UV_RemoveSite(afs_int32 server, afs_int32 part, afs_int32 volid)
        /*this site doesnot exist  */
        fprintf(STDERR, "This site is not a replication site \n");
        vcode =
-           ubik_Call(VL_ReleaseLock, cstruct, 0, volid, RWVOL,
+           ubik_VL_ReleaseLock(cstruct, 0, volid, RWVOL,
                      LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
        if (vcode) {
            fprintf(STDERR, "Could not update entry for volume %lu \n",
                    (unsigned long)volid);
            PrintError("", vcode);
-           ubik_Call(VL_ReleaseLock, cstruct, 0, volid, RWVOL,
+           ubik_VL_ReleaseLock(cstruct, 0, volid, RWVOL,
                      LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
            return (vcode);
        }
@@ -4702,7 +4703,7 @@ UV_RemoveSite(afs_int32 server, afs_int32 part, afs_int32 volid)
        if (entry.nServers < 1) {       /*this is the last ref */
            VPRINT1("Deleting the VLDB entry for %u ...", volid);
            fflush(STDOUT);
-           vcode = ubik_Call(VL_DeleteEntry, cstruct, 0, volid, ROVOL);
+           vcode = ubik_VL_DeleteEntry(cstruct, 0, volid, ROVOL);
            if (vcode) {
                fprintf(STDERR,
                        "Could not delete VLDB entry for volume %lu \n",
@@ -4725,7 +4726,7 @@ UV_RemoveSite(afs_int32 server, afs_int32 part, afs_int32 volid)
                    "Could not release lock on volume entry for %lu \n",
                    (unsigned long)volid);
            PrintError("", vcode);
-           ubik_Call(VL_ReleaseLock, cstruct, 0, volid, RWVOL,
+           ubik_VL_ReleaseLock(cstruct, 0, volid, RWVOL,
                      LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
            return (vcode);
        }
@@ -4742,7 +4743,7 @@ UV_ChangeLocation(afs_int32 server, afs_int32 part, afs_int32 volid)
     struct nvldbentry entry, storeEntry;
     int index;
 
-    vcode = ubik_Call(VL_SetLock, cstruct, 0, volid, RWVOL, VLOP_ADDSITE);
+    vcode = ubik_VL_SetLock(cstruct, 0, volid, RWVOL, VLOP_ADDSITE);
     if (vcode) {
        fprintf(STDERR, " Could not lock the VLDB entry for volume %lu \n",
                (unsigned long)volid);
@@ -4764,7 +4765,7 @@ UV_ChangeLocation(afs_int32 server, afs_int32 part, afs_int32 volid)
        fprintf(STDERR, "No existing RW site for volume %lu",
                (unsigned long)volid);
        vcode =
-           ubik_Call(VL_ReleaseLock, cstruct, 0, volid, RWVOL,
+           ubik_VL_ReleaseLock(cstruct, 0, volid, RWVOL,
                      LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
        if (vcode) {
            fprintf(STDERR,
@@ -4786,7 +4787,7 @@ UV_ChangeLocation(afs_int32 server, afs_int32 part, afs_int32 volid)
            fprintf(STDERR, "Could not update entry for volume %lu \n",
                    (unsigned long)volid);
            PrintError("", vcode);
-           ubik_Call(VL_ReleaseLock, cstruct, 0, volid, RWVOL,
+           ubik_VL_ReleaseLock(cstruct, 0, volid, RWVOL,
                      LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
            return (vcode);
        }
@@ -4926,7 +4927,7 @@ UV_GenerateVolumeClones(afs_int32 aserver, afs_int32 apart,
        reuseCloneId = 1;
     else {                     /*get a bunch of id's from vldb */
        code =
-           ubik_Call(VL_GetNewVolumeId, cstruct, 0, arraySize, &curCloneId);
+           ubik_VL_GetNewVolumeId(cstruct, 0, arraySize, &curCloneId);
        if (code) {
            fprintf(STDERR, "Could not get ID's for the clone from VLDB\n");
            PrintError("", code);
@@ -5249,7 +5250,7 @@ CheckVolume(volintInfo * volumeinfo, afs_int32 aserver, afs_int32 apart,
      * then make the changes to it (pass 2).
      */
     if (++pass == 2) {
-       code = ubik_Call(VL_SetLock, cstruct, 0, rwvolid, RWVOL, VLOP_DELETE);
+       code = ubik_VL_SetLock(cstruct, 0, rwvolid, RWVOL, VLOP_DELETE);
        if (code) {
            fprintf(STDERR, "Could not lock VLDB entry for %lu\n",
                    (unsigned long)rwvolid);
@@ -5622,7 +5623,7 @@ CheckVolume(volintInfo * volumeinfo, afs_int32 aserver, afs_int32 apart,
            *modentry = modified;
     } else if (pass == 2) {
        code =
-           ubik_Call(VL_ReleaseLock, cstruct, 0, rwvolid, RWVOL,
+           ubik_VL_ReleaseLock(cstruct, 0, rwvolid, RWVOL,
                      LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
        if (code) {
            PrintError("Could not unlock VLDB entry ", code);
@@ -5865,16 +5866,16 @@ UV_SyncVolume(afs_int32 aserver, afs_int32 apart, char *avolname, int flags)
     /* Now check if the maxvolid is larger than that stored in the VLDB */
     if (maxvolid) {
        afs_int32 maxvldbid = 0;
-       code = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 0, &maxvldbid);
+       code = ubik_VL_GetNewVolumeId(cstruct, 0, 0, &maxvldbid);
        if (code) {
            fprintf(STDERR,
                    "Could not get the highest allocated volume id from the VLDB\n");
            if (!error)
                error = code;
        } else if (maxvolid > maxvldbid) {
-           afs_uint32 id, nid;
+           afs_int32 id, nid;
            id = maxvolid - maxvldbid + 1;
-           code = ubik_Call(VL_GetNewVolumeId, cstruct, 0, id, &nid);
+           code = ubik_VL_GetNewVolumeId(cstruct, 0, id, &nid);
            if (code) {
                fprintf(STDERR,
                        "Error in increasing highest allocated volume id in VLDB\n");
@@ -6009,17 +6010,17 @@ UV_SyncVldb(afs_int32 aserver, afs_int32 apart, int flags, int force)
   error_exit:
     /* Now check if the maxvolid is larger than that stored in the VLDB */
     if (maxvolid) {
-       afs_uint32 maxvldbid = 0;
-       code = ubik_Call(VL_GetNewVolumeId, cstruct, 0, 0, &maxvldbid);
+       afs_int32 maxvldbid = 0;
+       code = ubik_VL_GetNewVolumeId(cstruct, 0, 0, &maxvldbid);
        if (code) {
            fprintf(STDERR,
                    "Could not get the highest allocated volume id from the VLDB\n");
            if (!error)
                error = code;
        } else if (maxvolid > maxvldbid) {
-           afs_uint32 id, nid;
+           afs_int32 id, nid;
            id = maxvolid - maxvldbid + 1;
-           code = ubik_Call(VL_GetNewVolumeId, cstruct, 0, id, &nid);
+           code = ubik_VL_GetNewVolumeId(cstruct, 0, id, &nid);
            if (code) {
                fprintf(STDERR,
                        "Error in increasing highest allocated volume id in VLDB\n");
@@ -6262,7 +6263,7 @@ CheckVldb(struct nvldbentry * entry, afs_int32 * modified)
      */
     if (++pass == 2) {
        code =
-           ubik_Call(VL_SetLock, cstruct, 0, entry->volumeId[RWVOL], RWVOL,
+           ubik_VL_SetLock(cstruct, 0, entry->volumeId[RWVOL], RWVOL,
                      VLOP_DELETE);
        if (code) {
            fprintf(STDERR, "Could not lock VLDB entry for %u \n",
@@ -6312,7 +6313,7 @@ CheckVldb(struct nvldbentry * entry, afs_int32 * modified)
            && !(entry->flags & RO_EXISTS)) {
            /* The RW, BK, nor RO volumes do not exist. Delete the VLDB entry */
            code =
-               ubik_Call(VL_DeleteEntry, cstruct, 0, entry->volumeId[RWVOL],
+               ubik_VL_DeleteEntry(cstruct, 0, entry->volumeId[RWVOL],
                          RWVOL);
            if (code) {
                fprintf(STDERR,
@@ -6354,7 +6355,7 @@ CheckVldb(struct nvldbentry * entry, afs_int32 * modified)
 
     if (islocked) {
        code =
-           ubik_Call(VL_ReleaseLock, cstruct, 0, entry->volumeId[RWVOL],
+           ubik_VL_ReleaseLock(cstruct, 0, entry->volumeId[RWVOL],
                      RWVOL,
                      (LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP));
        if (code) {
@@ -6479,7 +6480,7 @@ UV_RenameVolume(struct nvldbentry *entry, char oldname[], char newname[])
     tid = 0;
     islocked = 0;
 
-    vcode = ubik_Call(VL_SetLock, cstruct, 0, entry->volumeId[RWVOL], RWVOL, VLOP_ADDSITE);    /*last param is dummy */
+    vcode = ubik_VL_SetLock(cstruct, 0, entry->volumeId[RWVOL], RWVOL, VLOP_ADDSITE);  /*last param is dummy */
     if (vcode) {
        fprintf(STDERR,
                " Could not lock the VLDB entry for the  volume %u \n",
@@ -6665,7 +6666,7 @@ UV_RenameVolume(struct nvldbentry *entry, char oldname[], char newname[])
   rvfail:
     if (islocked) {
        vcode =
-           ubik_Call(VL_ReleaseLock, cstruct, 0, entry->volumeId[RWVOL],
+           ubik_VL_ReleaseLock(cstruct, 0, entry->volumeId[RWVOL],
                      RWVOL,
                      LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP);
        if (vcode) {