Make all VLDB interactions use VLF/VLSF names
authorNathaniel Wesley Filardo <nwfilardo@gmail.com>
Sat, 26 Jul 2014 19:05:19 +0000 (15:05 -0400)
committerJeffrey Altman <jaltman@your-file-system.com>
Thu, 4 Dec 2014 23:43:08 +0000 (18:43 -0500)
src/volser/volser.p.h defined the values used in VLDB entries.  These values
appear (by exhaustive walk of source and by inspection of the volser's rxrpc
api) to be unused by any aspect of the volser and were solely used in
communication with the VLDB.

This patch deletes the misplaced definitions and moves the entire tree to
use the VLF_{RW,RO,BACK}EXISTS and VLSF_* macros from vlserver/vldbint.xg .
No include wrangling was needed; these definitions have always been in scope
but relatively unused.

It also serves to head off a potential problem, which actually motivated the
whole thing: ITSRWREPL was 0x10, which was claimed as VLSF_UUID;
VLSF_RWREPLICA is 0x40, which did not have an ITS equivalent.  As ITSRWREPL
was not used, this had never shown itself in operation.  There was no ITS
semantic equivalent of VLSF_UUID.

Change-Id: I60426c2635976b9ac34bf820a8aec7a0c8575e20
Reviewed-on: http://gerrit.openafs.org/11331
Tested-by: BuildBot <buildbot@rampaginggeek.com>
Reviewed-by: Benjamin Kaduk <kaduk@mit.edu>
Reviewed-by: Jeffrey Altman <jaltman@your-file-system.com>

src/bucoord/commands.c
src/butc/dump.c
src/libadmin/vos/afs_vosAdmin.c
src/libadmin/vos/lockprocs.c
src/libadmin/vos/vosutils.c
src/libadmin/vos/vsprocs.c
src/volser/lockprocs.c
src/volser/volser.p.h
src/volser/vos.c
src/volser/vsprocs.c

index daeb791..554af79 100644 (file)
@@ -257,15 +257,15 @@ EvalVolumeSet2(struct bc_config *aconfig,
                ei = entries[e].matchindex & 0xffff;
                et = (entries[e].matchindex >> 16) & 0xffff;
                switch (et) {
-               case ITSRWVOL:{
+               case VLSF_RWVOL:{
                        et = RWVOL;
                        break;
                    }
-               case ITSBACKVOL:{
+               case VLSF_BACKVOL:{
                        et = BACKVOL;
                        break;
                    }
-               case ITSROVOL:{
+               case VLSF_ROVOL:{
                        et = ROVOL;
                        break;
                    }
@@ -502,8 +502,8 @@ EvalVolumeSet1(struct bc_config *aconfig,
                /* If the RW name matches the volume set entry, take
                 * it and exit. First choice is to use the RW volume.
                 */
-               if (entry.serverFlags[srvpartpair] & ITSRWVOL) {
-                   if (entry.flags & RW_EXISTS) {
+               if (entry.serverFlags[srvpartpair] & VLSF_RWVOL) {
+                   if (entry.flags & VLF_RWEXISTS) {
                        sprintf(patt, "%s", entry.name);
 #ifdef HAVE_POSIX_REGEX
                        code = regexec(&re, patt, 0, NULL, 0);
@@ -522,7 +522,7 @@ EvalVolumeSet1(struct bc_config *aconfig,
                    /* If the BK name matches the volume set entry, take
                     * it and exit. Second choice is to use the BK volume.
                     */
-                   if (entry.flags & BACK_EXISTS) {
+                   if (entry.flags & VLF_BACKEXISTS) {
                        sprintf(patt, "%s.backup", entry.name);
 #ifdef HAVE_POSIX_REGEX
                        code = regexec(&re, patt, 0, NULL, 0);
@@ -543,8 +543,8 @@ EvalVolumeSet1(struct bc_config *aconfig,
                 * it, but continue searching. Further entries may be
                 * RW or backup entries that will match.
                 */
-               else if (!found && (entry.serverFlags[srvpartpair] & ITSROVOL)
-                        && (entry.flags & RO_EXISTS)) {
+               else if (!found && (entry.serverFlags[srvpartpair] & VLSF_ROVOL)
+                        && (entry.flags & VLF_ROEXISTS)) {
                    sprintf(patt, "%s.readonly", entry.name);
 #ifdef HAVE_POSIX_REGEX
                    code = regexec(&re, patt, 0, NULL, 0);
index 7c836a6..2073522 100644 (file)
@@ -869,7 +869,7 @@ dumpPass(struct dumpRock * dparamsPtr, int passNumber)
 
            switch (curDump->vtype) {
            case BACKVOL:
-               if (!(vldbEntry.flags & BACK_EXISTS)) {
+               if (!(vldbEntry.flags & VLF_BACKEXISTS)) {
                    ErrorLog(0, taskId, 0, 0,
                             "Volume %s (%u) failed - Backup volume no longer exists\n",
                             curDump->name, curDump->vid);
@@ -881,7 +881,7 @@ dumpPass(struct dumpRock * dparamsPtr, int passNumber)
 
            case RWVOL:
                for (e = 0; e < vldbEntry.nServers; e++) {      /* Find the RW volume */
-                   if (vldbEntry.serverFlags[e] & ITSRWVOL)
+                   if (vldbEntry.serverFlags[e] & VLSF_RWVOL)
                        break;
                }
                break;
@@ -899,7 +899,7 @@ dumpPass(struct dumpRock * dparamsPtr, int passNumber)
 
                if (e >= vldbEntry.nServers) {  /* Didn't find RO volume */
                    for (e = 0; e < vldbEntry.nServers; e++) {  /* Find the first RO volume */
-                       if (vldbEntry.serverFlags[e] & ITSROVOL)
+                       if (vldbEntry.serverFlags[e] & VLSF_ROVOL)
                            break;
                    }
                }
index dfcef7f..49db8cb 100644 (file)
@@ -150,10 +150,10 @@ GetServerAndPart(struct nvldbentry *entry, int voltype, afs_int32 * server,
 
     /* Doesn't check for non-existance of backup volume */
     if ((voltype == RWVOL) || (voltype == BACKVOL)) {
-       vtype = ITSRWVOL;
+       vtype = VLSF_RWVOL;
        istart = 0;             /* seach the entire entry */
     } else {
-       vtype = ITSROVOL;
+       vtype = VLSF_ROVOL;
        /* Seach from beginning of entry or pick up where we left off */
        istart = ((*previdx < 0) ? 0 : *previdx + 1);
     }
@@ -240,7 +240,7 @@ vos_BackupVolumeCreate(const void *cellHandle, vos_MessageCallBack_t callBack,
      * same server as volumeId
      */
 
-    if (rw_vol_entry.flags & BACK_EXISTS) {
+    if (rw_vol_entry.flags & VLF_BACKEXISTS) {
        if (!GetVolumeInfo
            (c_handle, rw_vol_entry.volumeId[BACKVOL], &bk_vol_entry,
             &bk_server, &bk_partition, &bk_vol_type, &tst)) {
@@ -392,7 +392,7 @@ vos_BackupVolumeCreateMultiple(const void *cellHandle,
         * Skip entries that don't have a RW volume
         */
 
-       if (!(entry->flags & RW_EXISTS)) {
+       if (!(entry->flags & VLF_RWEXISTS)) {
            if (callBack != NULL) {
                const char *messageText;
                if (util_AdminErrorCodeTranslate
@@ -1879,19 +1879,19 @@ copyVLDBEntry(struct nvldbentry *source, vos_vldbEntry_p dest,
        dest->volumeSites[i].serverPartition = source->serverPartition[i];
        dest->volumeSites[i].serverFlags = 0;
 
-       if (source->serverFlags[i] & NEW_REPSITE) {
+       if (source->serverFlags[i] & VLSF_NEWREPSITE) {
            dest->volumeSites[i].serverFlags |= VOS_VLDB_NEW_REPSITE;
        }
-       if (source->serverFlags[i] & ITSROVOL) {
+       if (source->serverFlags[i] & VLSF_ROVOL) {
            dest->volumeSites[i].serverFlags |= VOS_VLDB_READ_ONLY;
        }
-       if (source->serverFlags[i] & ITSRWVOL) {
+       if (source->serverFlags[i] & VLSF_RWVOL) {
            dest->volumeSites[i].serverFlags |= VOS_VLDB_READ_WRITE;
        }
-       if (source->serverFlags[i] & ITSBACKVOL) {
+       if (source->serverFlags[i] & VLSF_BACKVOL) {
            dest->volumeSites[i].serverFlags |= VOS_VLDB_BACKUP;
        }
-       if (source->serverFlags[i] & RO_DONTUSE) {
+       if (source->serverFlags[i] & VLSF_DONTUSE) {
            dest->volumeSites[i].serverFlags |= VOS_VLDB_DONT_USE;
        }
 
index 85b9133..33c9886 100644 (file)
@@ -35,7 +35,7 @@ FindIndex(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
                && (!server || equal)) {
                break;
            }
-           if (type == ITSRWVOL) {
+           if (type == VLSF_RWVOL) {
                /* quit when we are looking for RW entry (there's only 1) */
                return -1;
            }
@@ -80,7 +80,7 @@ Lp_SetRWValue(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
              afs_int32 oserver, afs_int32 opart, afs_int32 nserver,
              afs_int32 npart)
 {
-    SetAValue(cellHandle, entry, oserver, opart, nserver, npart, ITSRWVOL);
+    SetAValue(cellHandle, entry, oserver, opart, nserver, npart, VLSF_RWVOL);
 }
 
 /* Changes the RO site only */
@@ -89,7 +89,7 @@ Lp_SetROValue(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
              afs_int32 oserver, afs_int32 opart, afs_int32 nserver,
              afs_int32 npart)
 {
-    SetAValue(cellHandle, entry, oserver, opart, nserver, npart, ITSROVOL);
+    SetAValue(cellHandle, entry, oserver, opart, nserver, npart, VLSF_ROVOL);
 }
 
 /* Returns success if this server and partition matches the RW entry */
@@ -97,7 +97,7 @@ int
 Lp_Match(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
         afs_int32 server, afs_int32 part, afs_status_p st)
 {
-    if (FindIndex(cellHandle, entry, server, part, ITSRWVOL) == -1)
+    if (FindIndex(cellHandle, entry, server, part, VLSF_RWVOL) == -1)
        return 0;
     return 1;
 }
@@ -107,7 +107,7 @@ int
 Lp_ROMatch(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
           afs_int32 server, afs_int32 part, afs_status_p st)
 {
-    return (FindIndex(cellHandle, entry, server, part, ITSROVOL) + 1);
+    return (FindIndex(cellHandle, entry, server, part, VLSF_ROVOL) + 1);
 }
 
 /* Return the index of the RW entry if it exists, else return -1 */
@@ -115,7 +115,7 @@ int
 Lp_GetRwIndex(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
              afs_status_p st)
 {
-    return (FindIndex(cellHandle, entry, 0, 0, ITSRWVOL));
+    return (FindIndex(cellHandle, entry, 0, 0, VLSF_RWVOL));
 }
 
 /*initialize queue pointed by <ahead>*/
index b4ee7d4..1b99d2b 100644 (file)
@@ -428,8 +428,8 @@ GetVolumeInfo(afs_cell_handle_p cellHandle, afs_uint32 volid,
     if (volid == rentry->volumeId[ROVOL]) {
        *voltype = ROVOL;
        for (i = 0; i < rentry->nServers; i++) {
-           if ((index == -1) && (rentry->serverFlags[i] & ITSROVOL)
-               && !(rentry->serverFlags[i] & RO_DONTUSE))
+           if ((index == -1) && (rentry->serverFlags[i] & VLSF_ROVOL)
+               && !(rentry->serverFlags[i] & VLSF_DONTUSE))
                index = i;
        }
        if (index == -1) {
index b54d995..28072a4 100644 (file)
@@ -161,8 +161,8 @@ UV_CreateVolume(afs_cell_handle_p cellHandle, struct rx_connection *server,
     entry.nServers = 1;
     entry.serverNumber[0] = ntohl(rx_HostOf(rx_PeerOf(server)));
     entry.serverPartition[0] = partition;
-    entry.flags = RW_EXISTS;
-    entry.serverFlags[0] = ITSRWVOL;
+    entry.flags = VLF_RWEXISTS;
+    entry.serverFlags[0] = VLSF_RWVOL;
     entry.volumeId[RWVOL] = *volumeId;
     entry.volumeId[ROVOL] = *volumeId + 1;
     entry.volumeId[BACKVOL] = *volumeId + 2;
@@ -258,13 +258,13 @@ UV_DeleteVolume(afs_cell_handle_p cellHandle, struct rx_connection *server,
     }
 
     if (volumeId == entry.volumeId[BACKVOL]) {
-       if (!(entry.flags & BACK_EXISTS)
+       if (!(entry.flags & VLF_BACKEXISTS)
            || !Lp_Match(cellHandle, &entry, serverAddr, partition, &tst)) {
            notinvldb = 2;
            goto fail_UV_DeleteVolume;
        }
 
-       entry.flags &= ~BACK_EXISTS;
+       entry.flags &= ~VLF_BACKEXISTS;
        vtype = BACKVOL;
     }
 
@@ -277,13 +277,13 @@ UV_DeleteVolume(afs_cell_handle_p cellHandle, struct rx_connection *server,
        Lp_SetROValue(cellHandle, &entry, serverAddr, partition, 0, 0);
        entry.nServers--;
        if (!Lp_ROMatch(cellHandle, &entry, 0, 0, &tst)) {
-           entry.flags &= ~RO_EXISTS;
+           entry.flags &= ~VLF_ROEXISTS;
        }
        vtype = ROVOL;
     }
 
     else if (volumeId == entry.volumeId[RWVOL]) {
-       if (!(entry.flags & RW_EXISTS)
+       if (!(entry.flags & VLF_RWEXISTS)
            || !Lp_Match(cellHandle, &entry, serverAddr, partition, &tst)) {
            notinvldb = 2;
            goto fail_UV_DeleteVolume;
@@ -308,7 +308,7 @@ UV_DeleteVolume(afs_cell_handle_p cellHandle, struct rx_connection *server,
 
        Lp_SetRWValue(cellHandle, &entry, serverAddr, partition, 0L, 0L);
        entry.nServers--;
-       entry.flags &= ~(BACK_EXISTS | RW_EXISTS);
+       entry.flags &= ~(VLF_BACKEXISTS | VLF_RWEXISTS);
        vtype = RWVOL;
 
     }
@@ -318,7 +318,7 @@ UV_DeleteVolume(afs_cell_handle_p cellHandle, struct rx_connection *server,
        goto fail_UV_DeleteVolume;
     }
 
-    if ((entry.nServers <= 0) || !(entry.flags & (RO_EXISTS | RW_EXISTS))) {
+    if ((entry.nServers <= 0) || !(entry.flags & (VLF_ROEXISTS | VLF_RWEXISTS))) {
        tst = ubik_VL_DeleteEntry(cellHandle->vos, 0, volumeId, vtype);
        if (tst) {
            goto fail_UV_DeleteVolume;
@@ -717,7 +717,7 @@ UV_MoveVolume(afs_cell_handle_p cellHandle, afs_uint32 afromvol,
     Lp_SetRWValue(cellHandle, &entry, afromserver, afrompart, atoserver,
                  atopart);
     store_flags = entry.flags;
-    entry.flags &= ~BACK_EXISTS;
+    entry.flags &= ~VLF_BACKEXISTS;
 
     if (!VLDB_ReplaceEntry
        (cellHandle, afromvol, -1, &entry,
@@ -993,7 +993,7 @@ UV_BackupVolume(afs_cell_handle_p cellHandle, afs_int32 aserver,
     /* 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 */
@@ -1084,8 +1084,8 @@ UV_BackupVolume(afs_cell_handle_p cellHandle, afs_int32 aserver,
     }
 
     /* Mork vldb as backup exists */
-    if (!(entry.flags & BACK_EXISTS)) {
-       entry.flags |= BACK_EXISTS;
+    if (!(entry.flags & VLF_BACKEXISTS)) {
+       entry.flags |= VLF_BACKEXISTS;
        vldbmod = 1;
     }
 
@@ -1538,7 +1538,7 @@ UV_ReleaseVolume(afs_cell_handle_p cellHandle, afs_uint32 afromvol,
 
     /* Will we be completing a previously unfinished release. -force overrides */
     for (fullrelease = 1, i = 0; (fullrelease && (i < entry.nServers)); i++) {
-       if (entry.serverFlags[i] & NEW_REPSITE)
+       if (entry.serverFlags[i] & VLSF_NEWREPSITE)
            fullrelease = 0;
     }
     if (forceflag && !fullrelease)
@@ -1566,7 +1566,7 @@ UV_ReleaseVolume(afs_cell_handle_p cellHandle, afs_uint32 afromvol,
         * want to "reclone" a temporary RO clone.
         */
        if (roexists
-           && (!roclone || (entry.serverFlags[roindex] & RO_DONTUSE))) {
+           && (!roclone || (entry.serverFlags[roindex] & VLSF_DONTUSE))) {
            tst = DelVol(fromconn, cloneVolId, afrompart, ITOffline);
            if (tst && (tst != VNOVOL)) {
                goto fail_UV_ReleaseVolume;
@@ -1579,11 +1579,11 @@ UV_ReleaseVolume(afs_cell_handle_p cellHandle, afs_uint32 afromvol,
         * RO volume is released (temp RO clones don't count).
         */
        for (i = 0; i < entry.nServers; i++) {
-           entry.serverFlags[i] &= ~NEW_REPSITE;
-           entry.serverFlags[i] |= RO_DONTUSE;
+           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 */
        tst =
@@ -1663,9 +1663,9 @@ UV_ReleaseVolume(afs_cell_handle_p cellHandle, afs_uint32 afromvol,
                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++;
 
@@ -1731,10 +1731,10 @@ UV_ReleaseVolume(afs_cell_handle_p cellHandle, afs_uint32 afromvol,
 
            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 */
 
 
@@ -1839,9 +1839,9 @@ UV_ReleaseVolume(afs_cell_handle_p cellHandle, afs_uint32 afromvol,
                    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++;
            }
        }
@@ -1877,7 +1877,7 @@ UV_ReleaseVolume(afs_cell_handle_p cellHandle, afs_uint32 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) {
@@ -1900,7 +1900,7 @@ UV_ReleaseVolume(afs_cell_handle_p cellHandle, afs_uint32 afromvol,
     entry.cloneId = 0;
 
     for (i = 0; i < entry.nServers; i++)
-       entry.serverFlags[i] &= ~NEW_REPSITE;
+       entry.serverFlags[i] &= ~VLSF_NEWREPSITE;
 
     /* Update the VLDB */
     if (!VLDB_ReplaceEntry
@@ -2418,8 +2418,8 @@ UV_RestoreVolume(afs_cell_handle_p cellHandle, afs_int32 toserver,
            entry.nServers = 1;
            entry.serverNumber[0] = toserver;   /*should be indirect */
            entry.serverPartition[0] = topart;
-           entry.serverFlags[0] = ITSRWVOL;
-           entry.flags = RW_EXISTS;
+           entry.serverFlags[0] = VLSF_RWVOL;
+           entry.flags = VLF_RWEXISTS;
            if (tstatus.cloneID != 0) {
                entry.volumeId[ROVOL] = tstatus.cloneID;        /*this should come from status info on the volume if non zero */
            } else
@@ -2451,7 +2451,7 @@ UV_RestoreVolume(afs_cell_handle_p cellHandle, afs_int32 toserver,
                /* Add the rw site for the volume being restored */
                entry.serverNumber[entry.nServers] = toserver;
                entry.serverPartition[entry.nServers] = topart;
-               entry.serverFlags[entry.nServers] = ITSRWVOL;
+               entry.serverFlags[entry.nServers] = VLSF_RWVOL;
                entry.nServers++;
            } else {
                /* This volume should be deleted on the old site
@@ -2495,7 +2495,7 @@ UV_RestoreVolume(afs_cell_handle_p cellHandle, afs_int32 toserver,
                entry.serverPartition[index] = topart;
            }
 
-           entry.flags |= RW_EXISTS;
+           entry.flags |= VLF_RWEXISTS;
            if (!VLDB_ReplaceEntry
                (cellHandle, pvolid, RWVOL, &entry,
                 LOCKREL_OPCODE | LOCKREL_AFSID | LOCKREL_TIMESTAMP, &tst)) {
@@ -2587,7 +2587,7 @@ UV_AddSite(afs_cell_handle_p cellHandle, afs_int32 server, afs_int32 part,
 
     /* 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
                (cellHandle, server, entry.serverNumber[j], &same, &tst)) {
@@ -2608,7 +2608,7 @@ UV_AddSite(afs_cell_handle_p cellHandle, afs_int32 server, afs_int32 part,
 
     entry.serverNumber[entry.nServers] = server;
     entry.serverPartition[entry.nServers] = part;
-    entry.serverFlags[entry.nServers] = (ITSROVOL | RO_DONTUSE);
+    entry.serverFlags[entry.nServers] = (VLSF_ROVOL | VLSF_DONTUSE);
     entry.nServers++;
 
     if (!VLDB_ReplaceEntry
@@ -2659,8 +2659,8 @@ UV_RemoveSite(afs_cell_handle_p cellHandle, afs_int32 server, afs_int32 part,
     } else {                   /*remove the rep site */
        Lp_SetROValue(cellHandle, &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 */
            tst = ubik_VL_DeleteEntry(cellHandle->vos, 0, volid, ROVOL);
            if (tst) {
@@ -3033,8 +3033,8 @@ ProcessEntries(afs_cell_handle_p cellHandle, struct qHead *myQueue,
            memset(&entry, 0, sizeof(entry));
            strncpy(entry.name, elem.name, VOLSER_OLDMAXVOLNAME);
            if (elem.isValid[RWVOL]) {  /*rw exists */
-               entry.flags |= RW_EXISTS;
-               entry.serverFlags[entry.nServers] = ITSRWVOL;
+               entry.flags |= VLF_RWEXISTS;
+               entry.serverFlags[entry.nServers] = VLSF_RWVOL;
                entry.serverNumber[entry.nServers] = aserver;
                entry.serverPartition[entry.nServers] = apart;
                entry.nServers += 1;
@@ -3043,8 +3043,8 @@ ProcessEntries(afs_cell_handle_p cellHandle, struct qHead *myQueue,
                entry.volumeId[BACKVOL] = elem.ids[BACKVOL];
            }
            if (elem.isValid[ROVOL]) {  /*ro volume exists */
-               entry.flags |= RO_EXISTS;
-               entry.serverFlags[entry.nServers] = ITSROVOL;
+               entry.flags |= VLF_ROEXISTS;
+               entry.serverFlags[entry.nServers] = VLSF_ROVOL;
                entry.serverNumber[entry.nServers] = aserver;
                entry.serverPartition[entry.nServers] = apart;
                entry.nServers += 1;
@@ -3053,9 +3053,9 @@ ProcessEntries(afs_cell_handle_p cellHandle, struct qHead *myQueue,
 
            }
            if (elem.isValid[BACKVOL]) {        /*backup volume exists */
-               entry.flags |= BACK_EXISTS;
-               if (!(entry.flags & RW_EXISTS)) {       /*this helps to check for a stray backup if parent moves */
-                   entry.serverFlags[entry.nServers] = ITSRWVOL;
+               entry.flags |= VLF_BACKEXISTS;
+               if (!(entry.flags & VLF_RWEXISTS)) {    /*this helps to check for a stray backup if parent moves */
+                   entry.serverFlags[entry.nServers] = VLSF_RWVOL;
                    entry.serverNumber[entry.nServers] = aserver;
                    entry.serverPartition[entry.nServers] = apart;
                    entry.nServers += 1;
@@ -3079,10 +3079,10 @@ ProcessEntries(afs_cell_handle_p cellHandle, struct qHead *myQueue,
                if (temp == -1) {
                    /* A RW index is not found in the VLDB entry - will add it */
 
-                   entry.flags |= RW_EXISTS;
+                   entry.flags |= VLF_RWEXISTS;
                    entry.serverNumber[entry.nServers] = aserver;
                    entry.serverPartition[entry.nServers] = apart;
-                   entry.serverFlags[entry.nServers] = ITSRWVOL;
+                   entry.serverFlags[entry.nServers] = VLSF_RWVOL;
                    entry.nServers++;
                } else {
                    /* A RW index is found in the VLDB entry.
@@ -3103,7 +3103,7 @@ ProcessEntries(afs_cell_handle_p cellHandle, struct qHead *myQueue,
                        entry.serverPartition[temp] = apart;
 
                    }
-                   entry.flags |= RW_EXISTS;
+                   entry.flags |= VLF_RWEXISTS;
                }
                if ((elem.ids[BACKVOL] != 0) && elem.isValid[BACKVOL])
                    entry.volumeId[BACKVOL] = elem.ids[BACKVOL];
@@ -3127,14 +3127,14 @@ ProcessEntries(afs_cell_handle_p cellHandle, struct qHead *myQueue,
                        count = entry.nServers;
                        rwsite = -1;
                        for (j = 0; j < count; j++) {
-                           if (entry.serverFlags[j] & ITSROVOL) {
+                           if (entry.serverFlags[j] & VLSF_ROVOL) {
 
                                /*delete the site */
                                entry.serverNumber[j] = 0;
                                entry.serverPartition[j] = 0;
                                entry.serverFlags[j] = 0;
 
-                           } else if (entry.serverFlags[j] & ITSRWVOL)
+                           } else if (entry.serverFlags[j] & VLSF_RWVOL)
                                rwsite = j;
                        }
                        entry.nServers = 0;
@@ -3149,19 +3149,19 @@ ProcessEntries(afs_cell_handle_p cellHandle, struct qHead *myQueue,
                        }
                        entry.serverNumber[entry.nServers] = aserver;
                        entry.serverPartition[entry.nServers] = apart;
-                       entry.serverFlags[entry.nServers] = ITSROVOL;
+                       entry.serverFlags[entry.nServers] = VLSF_ROVOL;
                        entry.nServers++;
                        entry.volumeId[ROVOL] = elem.ids[ROVOL];
-                       entry.flags |= RO_EXISTS;
+                       entry.flags |= VLF_ROEXISTS;
 
                    } else if (elem.ids[ROVOL] < entry.volumeId[ROVOL]) {
-                       if (!(entry.flags & RO_EXISTS)) {
+                       if (!(entry.flags & VLF_ROEXISTS)) {
                            entry.volumeId[ROVOL] = elem.ids[ROVOL];
                            entry.serverNumber[entry.nServers] = aserver;
                            entry.serverPartition[entry.nServers] = apart;
-                           entry.serverFlags[entry.nServers] = ITSROVOL;
+                           entry.serverFlags[entry.nServers] = VLSF_ROVOL;
                            entry.nServers++;
-                           entry.flags |= RO_EXISTS;
+                           entry.flags |= VLF_ROEXISTS;
                        }
 
                    }
@@ -3169,9 +3169,9 @@ ProcessEntries(afs_cell_handle_p cellHandle, struct qHead *myQueue,
                    else if (elem.ids[ROVOL] == entry.volumeId[ROVOL]) {
                        entry.serverNumber[entry.nServers] = aserver;
                        entry.serverPartition[entry.nServers] = apart;
-                       entry.serverFlags[entry.nServers] = ITSROVOL;
+                       entry.serverFlags[entry.nServers] = VLSF_ROVOL;
                        entry.nServers++;
-                       entry.flags |= RO_EXISTS;
+                       entry.flags |= VLF_ROEXISTS;
                        entry.volumeId[ROVOL] = elem.ids[ROVOL];
                    }
                }
@@ -3192,7 +3192,7 @@ ProcessEntries(afs_cell_handle_p cellHandle, struct qHead *myQueue,
                } else {
                    /*tackle the backup volume */
                    entry.volumeId[BACKVOL] = elem.ids[BACKVOL];
-                   entry.flags |= BACK_EXISTS;
+                   entry.flags |= VLF_BACKEXISTS;
                }
                if (entry.volumeId[BACKVOL] == INVALID_BID)
                    entry.volumeId[BACKVOL] = elem.ids[BACKVOL];
@@ -3328,65 +3328,65 @@ CheckVldbRWBK(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
        *modified = 0;
     idx = Lp_GetRwIndex(cellHandle, entry, 0);
 
-    /* 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 {
        if (VolumeExists
            (cellHandle, entry->serverNumber[idx],
             entry->serverPartition[idx], entry->volumeId[RWVOL], &tst)) {
-           if (!(entry->flags & RW_EXISTS)) {  /* ... yet entry says RW does no
+           if (!(entry->flags & VLF_RWEXISTS)) {       /* ... yet entry says RW does no
                                                 * t exist */
-               entry->flags |= RW_EXISTS;      /* ... so say RW does exist */
+               entry->flags |= VLF_RWEXISTS;   /* ... so say RW does exist */
                modentry++;
            }
        } else if (tst == ENODEV) {     /* RW volume does not exist */
-           if (entry->flags & RW_EXISTS) {     /* ... yet entry says RW exists
+           if (entry->flags & VLF_RWEXISTS) {  /* ... yet entry says RW exists
                                                 */
-               entry->flags &= ~RW_EXISTS;     /* ... so say RW does not exist
+               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) {
                goto fail_CheckVldbRWBK;
            }
        }
     }
 
-    /* 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 */
        if (VolumeExists
            (cellHandle, entry->serverNumber[idx],
             entry->serverPartition[idx], entry->volumeId[BACKVOL], &tst)) {
-           if (!(entry->flags & BACK_EXISTS)) {        /* ... yet entry says BK does n
+           if (!(entry->flags & VLF_BACKEXISTS)) {     /* ... yet entry says BK does n
                                                         * ot exist */
-               entry->flags |= BACK_EXISTS;    /* ... so say BK does exist */
+               entry->flags |= VLF_BACKEXISTS; /* ... so say BK does exist */
                modentry++;
            }
        } else if (tst == ENODEV) {     /* BK volume does not exist */
-           if (entry->flags & BACK_EXISTS) {   /* ... yet entry says BK exists
+           if (entry->flags & VLF_BACKEXISTS) {        /* ... yet entry says BK exists
                                                 */
-               entry->flags &= ~BACK_EXISTS;   /* ... so say BK does not exist
+               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) {
                goto fail_CheckVldbRWBK;
            }
        }
@@ -3395,8 +3395,8 @@ CheckVldbRWBK(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
     /* 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(cellHandle, entry, entry->serverNumber[idx],
                      entry->serverPartition[idx], 0L, 0L);
        entry->nServers--;
@@ -3428,11 +3428,11 @@ CheckVldbRO(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
     if (modified)
        *modified = 0;
 
-    /* Check to see if the RO volumes exist and set the RO_EXISTS
+    /* 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 */
        }
 
@@ -3452,14 +3452,14 @@ CheckVldbRO(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
     }
 
     if (foundro) {             /* A RO volume exists */
-       if (!(entry->flags & RO_EXISTS)) {      /* ... yet entry says RW does not e
+       if (!(entry->flags & VLF_ROEXISTS)) {   /* ... yet entry says RW does not e
                                                 * xist */
-           entry->flags |= RO_EXISTS;  /* ... so say RW does 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++;
        }
     }
@@ -3541,8 +3541,8 @@ CheckVldb(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
        if (pass == 1)
            goto retry;
 
-       if (!(entry->flags & RW_EXISTS) && !(entry->flags & BACK_EXISTS)
-           && !(entry->flags & RO_EXISTS)) {
+       if (!(entry->flags & VLF_RWEXISTS) && !(entry->flags & VLF_BACKEXISTS)
+           && !(entry->flags & VLF_ROEXISTS)) {
            /* The RW, BK, nor RO volumes do not exist. Delete the VLDB entry */
            tst =
                ubik_VL_DeleteEntry(cellHandle->vos, 0,
@@ -3690,7 +3690,7 @@ UV_RenameVolume(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
     /*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(cellHandle, entry, 0);
        if (index == -1) {      /* there is a serious discrepancy */
            tst = VOLSERVLDB_ERROR;
@@ -3726,7 +3726,7 @@ UV_RenameVolume(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
        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(cellHandle, entry, 0);
        if (index == -1) {      /* there is a serious discrepancy */
            tst = VOLSERVLDB_ERROR;
@@ -3764,9 +3764,9 @@ UV_RenameVolume(afs_cell_handle_p cellHandle, struct nvldbentry *entry,
     if (aconn)
        rx_ReleaseCachedConnection(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(cellHandle, entry->serverNumber[i],
                            AFSCONF_VOLUMEPORT);
index e3f6a13..691a523 100644 (file)
@@ -50,7 +50,7 @@ FindIndex(struct nvldbentry *entry, afs_uint32 server, afs_int32 part, afs_int32
                    || VLDB_IsSameAddrs(entry->serverNumber[e], server,
                                        &error)))
                break;
-           if (type == ITSRWVOL)
+           if (type == VLSF_RWVOL)
                return -1;      /* quit when we are looking for RW entry (there's only 1) */
        }
     }
@@ -97,7 +97,7 @@ void
 Lp_SetRWValue(struct nvldbentry *entry, afs_uint32 oserver, afs_int32 opart,
               afs_uint32 nserver, afs_int32 npart)
 {
-    SetAValue(entry, oserver, opart, nserver, npart, ITSRWVOL);
+    SetAValue(entry, oserver, opart, nserver, npart, VLSF_RWVOL);
 }
 
 /* Changes the RO site only */
@@ -105,7 +105,7 @@ void
 Lp_SetROValue(struct nvldbentry *entry, afs_uint32 oserver,
               afs_int32 opart, afs_uint32 nserver, afs_int32 npart)
 {
-    SetAValue(entry, oserver, opart, nserver, npart, ITSROVOL);
+    SetAValue(entry, oserver, opart, nserver, npart, VLSF_ROVOL);
 }
 
 /* Returns success if this server and partition matches the RW entry */
@@ -113,7 +113,7 @@ int
 Lp_Match(afs_uint32 server, afs_int32 part,
          struct nvldbentry *entry)
 {
-    if (FindIndex(entry, server, part, ITSRWVOL) == -1)
+    if (FindIndex(entry, server, part, VLSF_RWVOL) == -1)
        return 0;
     return 1;
 }
@@ -122,14 +122,14 @@ Lp_Match(afs_uint32 server, afs_int32 part,
 int
 Lp_ROMatch(afs_uint32 server, afs_int32 part, struct nvldbentry *entry)
 {
-    return (FindIndex(entry, server, part, ITSROVOL) + 1);
+    return (FindIndex(entry, server, part, VLSF_ROVOL) + 1);
 }
 
 /* Return the index of the RW entry if it exists, else return -1 */
 int
 Lp_GetRwIndex(struct nvldbentry *entry)
 {
-    return (FindIndex(entry, 0, 0, ITSRWVOL));
+    return (FindIndex(entry, 0, 0, VLSF_RWVOL));
 }
 
 /*initialize queue pointed by <ahead>*/
index afe391f..0fab09f 100644 (file)
@@ -143,19 +143,6 @@ struct partList {          /*used by the backup system */
 
 #define ISNAMEVALID(name) (strlen(name) < (VOLSER_OLDMAXVOLNAME - 9))
 
-/* values for flags in struct nvldbEntry */
-#define RW_EXISTS 0x1000
-#define RO_EXISTS 0x2000
-#define BACK_EXISTS 0x4000
-
-/* values for serverFlags in struct nvldbEntry */
-#define NEW_REPSITE 0x01
-#define ITSROVOL    0x02
-#define ITSRWVOL    0x04
-#define ITSBACKVOL  0x08
-#define ITSRWREPL   0x10
-#define RO_DONTUSE  0x20
-
 #define PARTVALID 0x01
 #define CLONEVALID 0x02
 #define CLONEZAPPED 0x04
index 719c954..be2958d 100644 (file)
@@ -1414,10 +1414,10 @@ GetServerAndPart(struct nvldbentry *entry, int voltype, afs_uint32 *server,
 
     /* Doesn't check for non-existance of backup volume */
     if ((voltype == RWVOL) || (voltype == BACKVOL)) {
-       vtype = ITSRWVOL;
+       vtype = VLSF_RWVOL;
        istart = 0;             /* seach the entire entry */
     } else {
-       vtype = ITSROVOL;
+       vtype = VLSF_ROVOL;
        /* Seach from beginning of entry or pick up where we left off */
        istart = ((*previdx < 0) ? 0 : *previdx + 1);
     }
@@ -1677,7 +1677,7 @@ ExamineVolume(struct cmd_syndesc *as, void *arock)
        if (code) {
            error = code;
            if (code == ENODEV) {
-               if ((voltype == BACKVOL) && !(entry.flags & BACK_EXISTS)) {
+               if ((voltype == BACKVOL) && !(entry.flags & VLF_BACKEXISTS)) {
                    /* The VLDB says there is no backup volume and its not on disk */
                    fprintf(STDERR, "Volume %s does not exist\n",
                            as->parms[0].items->data);
@@ -1702,7 +1702,7 @@ ExamineVolume(struct cmd_syndesc *as, void *arock)
            } else
                VolumeStats_int(pntr, &entry, aserver, apart, voltype);
 
-           if ((voltype == BACKVOL) && !(entry.flags & BACK_EXISTS)) {
+           if ((voltype == BACKVOL) && !(entry.flags & VLF_BACKEXISTS)) {
                /* The VLDB says there is no backup volume yet we found one on disk */
                fprintf(STDERR, "Volume %s does not exist in VLDB\n",
                        as->parms[0].items->data);
@@ -2081,7 +2081,7 @@ DeleteAll(struct nvldbentry *entry)
     for (i = 0; i < entry->nServers; i++) {
        curserver = entry->serverNumber[i];
        curpart = entry->serverPartition[i];
-       if (entry->serverFlags[i] & ITSROVOL) {
+       if (entry->serverFlags[i] & VLSF_ROVOL) {
            volid = entry->volumeId[ROVOL];
        } else {
            volid = entry->volumeId[RWVOL];
@@ -2158,9 +2158,9 @@ DeleteVolume(struct cmd_syndesc *as, void *arock)
            return (code);
        }
 
-       if (((volid == entry.volumeId[RWVOL]) && (entry.flags & RW_EXISTS))
+       if (((volid == entry.volumeId[RWVOL]) && (entry.flags & VLF_RWEXISTS))
            || ((volid == entry.volumeId[BACKVOL])
-               && (entry.flags & BACK_EXISTS))) {
+               && (entry.flags & VLF_BACKEXISTS))) {
            idx = Lp_GetRwIndex(&entry);
            if ((idx == -1) || (server && (server != entry.serverNumber[idx]))
                || ((partition != -1)
@@ -2170,9 +2170,9 @@ DeleteVolume(struct cmd_syndesc *as, void *arock)
                return ENOENT;
            }
        } else if ((volid == entry.volumeId[ROVOL])
-                  && (entry.flags & RO_EXISTS)) {
+                  && (entry.flags & VLF_ROEXISTS)) {
            for (idx = -1, j = 0; j < entry.nServers; j++) {
-               if (!(entry.serverFlags[j] & ITSROVOL))
+               if (!(entry.serverFlags[j] & VLSF_ROVOL))
                    continue;
 
                if (((server == 0) || (server == entry.serverNumber[j]))
@@ -2845,7 +2845,7 @@ BackupVolume(struct cmd_syndesc *as, void *arock)
 
     /* is there a backup volume already? */
 
-    if (entry.flags & BACK_EXISTS) {
+    if (entry.flags & VLF_BACKEXISTS) {
        /* yep, where is it? */
 
        buvolid = entry.volumeId[BACKVOL];
@@ -4262,8 +4262,8 @@ GetVolumeInfo(afs_uint32 volid, afs_uint32 *server, afs_int32 *part, afs_int32 *
     if (volid == rentry->volumeId[ROVOL]) {
        *voltype = ROVOL;
        for (i = 0; i < rentry->nServers; i++) {
-           if ((index == -1) && (rentry->serverFlags[i] & ITSROVOL)
-               && !(rentry->serverFlags[i] & RO_DONTUSE))
+           if ((index == -1) && (rentry->serverFlags[i] & VLSF_ROVOL)
+               && !(rentry->serverFlags[i] & VLSF_DONTUSE))
                index = i;
        }
        if (index == -1) {
@@ -4506,9 +4506,9 @@ static int CompareVldbEntry(char *p1, char *p2)
     pos2 = -1;
 
     for(i = 0; i < arg1->nServers; i++)
-       if(arg1->serverFlags[i] & ITSRWVOL) pos1 = i;
+       if(arg1->serverFlags[i] & VLSF_RWVOL) pos1 = i;
     for(i = 0; i < arg2->nServers; i++)
-       if(arg2->serverFlags[i] & ITSRWVOL) pos2 = i;
+       if(arg2->serverFlags[i] & VLSF_RWVOL) pos2 = i;
     if(pos1 == -1 || pos2 == -1){
        pos1 = 0;
        pos2 = 0;
@@ -4966,7 +4966,7 @@ BackSys(struct cmd_syndesc *as, void *arock)
            continue;
        }
 
-       if (!(vllist->flags & RW_EXISTS)) {
+       if (!(vllist->flags & VLF_RWEXISTS)) {
            if (verbose) {
                fprintf(STDOUT,
                        "Omitting to backup %s since RW volume does not exist \n",
@@ -5609,12 +5609,12 @@ ConvertRO(struct cmd_syndesc *as, void *arock)
 
     MapHostToNetwork(&entry);
     for (i = 0; i < entry.nServers; i++) {
-       if (entry.serverFlags[i] & ITSRWVOL) {
+       if (entry.serverFlags[i] & VLSF_RWVOL) {
            rwserver = entry.serverNumber[i];
            rwpartition = entry.serverPartition[i];
            if (roserver)
                break;
-       } else if ((entry.serverFlags[i] & ITSROVOL) && !roserver) {
+       } else if ((entry.serverFlags[i] & VLSF_ROVOL) && !roserver) {
            same = VLDB_IsSameAddrs(server, entry.serverNumber[i], &code);
            if (code) {
                fprintf(STDERR,
index 75e30b8..ac7fcf4 100644 (file)
@@ -549,37 +549,37 @@ SubEnumerateEntry(struct nvldbentry *entry)
 
 #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++) {
@@ -587,18 +587,18 @@ SubEnumerateEntry(struct nvldbentry *entry)
        fprintf(STDOUT, "       server %s partition %s ",
                noresolve ? afs_inet_ntoa_r(entry->serverNumber[i], hoststr) :
                 hostutil_GetNameByINet(entry->serverNumber[i]), pname);
-       if (entry->serverFlags[i] & ITSRWVOL)
+       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");
@@ -795,8 +795,8 @@ UV_CreateVolume3(afs_uint32 aserver, afs_int32 apart, char *aname,
                                         * level of indirection later */
     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] = aroid ? *aroid : 0;
     entry.volumeId[BACKVOL] = abkid ? *abkid : 0;
@@ -863,8 +863,8 @@ UV_AddVLDBEntry(afs_uint32 aserver, afs_int32 apart, char *aname,
                                         * level of indirection later */
     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 */
@@ -955,14 +955,14 @@ UV_DeleteVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid)
        /* 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;
     }
 
@@ -985,7 +985,7 @@ UV_DeleteVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid)
        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;
     }
 
@@ -994,7 +994,7 @@ UV_DeleteVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid)
         * 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);
        }
@@ -1014,15 +1014,15 @@ UV_DeleteVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid)
                    "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");
     }
 
@@ -1032,7 +1032,7 @@ UV_DeleteVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid)
     }
 
     /* 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",
@@ -1392,13 +1392,13 @@ UV_ConvertRO(afs_uint32 server, afs_uint32 partition, afs_uint32 volid,
 
     /* extract information from the original entry */
     for (i = 0; i < entry->nServers; i++) {
-       if (entry->serverFlags[i] & ITSRWVOL) {
+       if (entry->serverFlags[i] & VLSF_RWVOL) {
            rwindex = i;
            rwserver = entry->serverNumber[i];
        /*  rwpartition = entry->serverPartition[i]; */
            if (roserver)
                break;
-       } else if ((entry->serverFlags[i] & ITSROVOL) && !roserver) {
+       } else if ((entry->serverFlags[i] & VLSF_ROVOL) && !roserver) {
            same = VLDB_IsSameAddrs(server, entry->serverNumber[i], &code);
            if (code) {
                fprintf(STDERR,
@@ -1429,7 +1429,7 @@ UV_ConvertRO(afs_uint32 server, afs_uint32 partition, afs_uint32 volid,
     /* 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] = ITSRWVOL;
+       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
@@ -1441,10 +1441,10 @@ UV_ConvertRO(afs_uint32 server, afs_uint32 partition, afs_uint32 volid,
        (entry->nServers)++;
        entry->serverNumber[newrwindex] = server;
        entry->serverPartition[newrwindex] = partition;
-       entry->serverFlags[newrwindex] = ITSRWVOL;
+       entry->serverFlags[newrwindex] = VLSF_RWVOL;
     }
-    entry->flags |= RW_EXISTS;
-    entry->flags &= ~BACK_EXISTS;
+    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 */
@@ -1461,11 +1461,11 @@ UV_ConvertRO(afs_uint32 server, afs_uint32 partition, afs_uint32 volid,
            entry->serverFlags[entry->nServers] = 0;
        }
     }
-    entry->flags &= ~RO_EXISTS;
+    entry->flags &= ~VLF_ROEXISTS;
     for (i = 0; i < entry->nServers; i++) {
-       if (entry->serverFlags[i] & ITSROVOL) {
-           if (!(entry->serverFlags[i] & (RO_DONTUSE | NEW_REPSITE)))
-               entry->flags |= RO_EXISTS;
+       if (entry->serverFlags[i] & VLSF_ROVOL) {
+           if (!(entry->serverFlags[i] & (VLSF_DONTUSE | VLSF_NEWREPSITE)))
+               entry->flags |= VLF_ROEXISTS;
        }
     }
     MapNetworkToHost(entry, &storeEntry);
@@ -1605,7 +1605,7 @@ UV_MoveVolume2(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
                    (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",
@@ -1911,7 +1911,7 @@ UV_MoveVolume2(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
 
     Lp_SetRWValue(&entry, afromserver, afrompart, atoserver, atopart);
     MapNetworkToHost(&entry, &storeEntry);
-    storeEntry.flags &= ~BACK_EXISTS;
+    storeEntry.flags &= ~VLF_BACKEXISTS;
 
     if (TESTC) {
        fprintf(STDOUT,
@@ -2049,7 +2049,7 @@ UV_MoveVolume2(afs_uint32 afromvol, afs_uint32 afromserver, afs_int32 afrompart,
 
     /* normal cleanup code */
 
-    if (entry.flags & RO_EXISTS)
+    if (entry.flags & VLF_ROEXISTS)
        fprintf(STDERR, "WARNING : readOnly copies still exist \n");
 
     if (islocked) {
@@ -2642,8 +2642,8 @@ cpincr:
        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;
@@ -2820,7 +2820,7 @@ UV_BackupVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid)
     /* 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 */
 
@@ -2878,8 +2878,8 @@ UV_BackupVolume(afs_uint32 aserver, afs_int32 apart, afs_uint32 avolid)
     }
 
     /* Mark vldb as backup exists */
-    if (!(entry.flags & BACK_EXISTS)) {
-       entry.flags |= BACK_EXISTS;
+    if (!(entry.flags & VLF_BACKEXISTS)) {
+       entry.flags |= VLF_BACKEXISTS;
        vldbmod = 1;
     }
 
@@ -3156,7 +3156,7 @@ GetTrans(struct nvldbentry *vldbEntryPtr, afs_int32 index,
                              vldbEntryPtr->serverPartition[index], ITOffline,
                              transPtr);
 
-       if (!code && (origflags[index] & RO_DONTUSE)) {
+       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
@@ -3594,11 +3594,11 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
      * or -force-reclone flag, to force this to be a complete release.
      */
     for (i = 0; i < entry.nServers; i++) {
-       if (entry.serverFlags[i] & ITSROVOL) {
+       if (entry.serverFlags[i] & VLSF_ROVOL) {
            sites++;
-           if (entry.serverFlags[i] & NEW_REPSITE)
+           if (entry.serverFlags[i] & VLSF_NEWREPSITE)
                new_sites++;
-           if (entry.serverFlags[i] & RO_DONTUSE)
+           if (entry.serverFlags[i] & VLSF_DONTUSE)
                notreleased++;
        }
        origflags[i] = entry.serverFlags[i];
@@ -3637,7 +3637,7 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
        error = 0;
 
        for (e = 0; (e < entry.nServers) && !error; e++) {
-           if ((entry.serverFlags[e] & ITSROVOL)) {
+           if ((entry.serverFlags[e] & VLSF_ROVOL)) {
                if (!(VLDB_IsSameAddrs(entry.serverNumber[e], afromserver,
                                       &error)))
                    break;
@@ -3769,7 +3769,7 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
        }
        /* clean up any previous tmp clone before starting if staying up */
        if (roexists
-           && (!roclone || (entry.serverFlags[roindex] & RO_DONTUSE))) {
+           && (!roclone || (entry.serverFlags[roindex] & VLSF_DONTUSE))) {
            code = DoVolDelete(fromconn,
                               stayUp ? entry.volumeId[ROVOL] : cloneVolId,
                               afrompart, "the", 0, NULL, NULL);
@@ -3785,10 +3785,10 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
                struct rx_connection *conn;
                afs_int32 crdate;
 
-               if (!(entry.serverFlags[vldbindex] & ITSROVOL)) {
+               if (!(entry.serverFlags[vldbindex] & VLSF_ROVOL)) {
                    continue;
                }
-               if ((entry.serverFlags[vldbindex] & RO_DONTUSE)) {
+               if ((entry.serverFlags[vldbindex] & VLSF_DONTUSE)) {
                    continue;
                }
                conn = UV_Bind(entry.serverNumber[vldbindex], AFSCONF_VOLUMEPORT);
@@ -3860,18 +3860,18 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
         */
        for (i = 0; i < entry.nServers; i++) {
            if (justnewsites) {
-               if ((entry.serverFlags[i] & RO_DONTUSE)) {
-                   entry.serverFlags[i] &= ~NEW_REPSITE;
+               if ((entry.serverFlags[i] & VLSF_DONTUSE)) {
+                   entry.serverFlags[i] &= ~VLSF_NEWREPSITE;
                } else {
-                   entry.serverFlags[i] |= NEW_REPSITE;
+                   entry.serverFlags[i] |= VLSF_NEWREPSITE;
                }
            } else {
-               entry.serverFlags[i] &= ~NEW_REPSITE;
-               entry.serverFlags[i] |= RO_DONTUSE;
+               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;
     }
 
     if (justnewsites && roexists) {
@@ -3903,11 +3903,11 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
            justnewsites = 0;
            /* reset the serverFlags as if 'justnewsites' had never been set */
            for (i = 0; i < entry.nServers; i++) {
-               entry.serverFlags[i] &= ~NEW_REPSITE;
-               entry.serverFlags[i] |= RO_DONTUSE;
+               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;
        }
 
        rwcrdate = volstatus.creationDate;
@@ -3948,9 +3948,9 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
                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++;
 
@@ -4024,9 +4024,9 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
 
     /* if we have a clone, treat this as done, for now */
     if (stayUp && !complete_release) {
-       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++;
     }
@@ -4049,10 +4049,10 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
 
            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 */
 
 
@@ -4224,9 +4224,9 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
                    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++;
            }
        }
@@ -4272,12 +4272,12 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
            }
            if (code) {
                EPRINT(code, "Failed: ");
-               entry.serverFlags[roindex] &= ~NEW_REPSITE;
-               entry.serverFlags[roindex] |= RO_DONTUSE;
+               entry.serverFlags[roindex] &= ~VLSF_NEWREPSITE;
+               entry.serverFlags[roindex] |= VLSF_DONTUSE;
            } else {
-               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;
                VDONE;
            }
 
@@ -4318,15 +4318,15 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
 
                if (code) {
                    if (!times[s].crtime) {
-                       entry.serverFlags[vldbindex] |= RO_DONTUSE;
+                       entry.serverFlags[vldbindex] |= VLSF_DONTUSE;
                    }
-                   entry.serverFlags[vldbindex] &= ~NEW_REPSITE;
+                   entry.serverFlags[vldbindex] &= ~VLSF_NEWREPSITE;
                    PrintError("Failed: ",
                               code);
                } else
                    VDONE;
 
-               if (entry.serverFlags[vldbindex] != RO_DONTUSE) {
+               if (entry.serverFlags[vldbindex] != VLSF_DONTUSE) {
                    /* bring it online (mark it InService) */
                    VPRINT1("Bringing readonly online on %s...",
                            noresolve ?
@@ -4341,8 +4341,8 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
                    /* needed to come online for cloning */
                    if (code) {
                        /* technically it's still new, just not online */
-                       entry.serverFlags[s] &= ~NEW_REPSITE;
-                       entry.serverFlags[s] |= RO_DONTUSE;
+                       entry.serverFlags[s] &= ~VLSF_NEWREPSITE;
+                       entry.serverFlags[s] |= VLSF_DONTUSE;
                        if (code != ENOENT) {
                            PrintError("Failed to set correct names and ids: ",
                                       code);
@@ -4402,7 +4402,7 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
 
     /* 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) {
@@ -4411,7 +4411,7 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
                "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",
                         noresolve ? afs_inet_ntoa_r(entry.serverNumber[i], hoststr) :
@@ -4443,7 +4443,7 @@ UV_ReleaseVolume(afs_uint32 afromvol, afs_uint32 afromserver,
     }
 
     for (i = 0; i < entry.nServers; i++)
-       entry.serverFlags[i] &= ~NEW_REPSITE;
+       entry.serverFlags[i] &= ~VLSF_NEWREPSITE;
 
     /* Update the VLDB */
     VPRINT("updating VLDB ...");
@@ -4846,7 +4846,7 @@ UV_RestoreVolume2(afs_uint32 toserver, afs_int32 topart, afs_uint32 tovolid,
            }
            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);
@@ -5038,8 +5038,8 @@ UV_RestoreVolume2(afs_uint32 toserver, afs_int32 topart, afs_uint32 tovolid,
            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) {
@@ -5095,7 +5095,7 @@ UV_RestoreVolume2(afs_uint32 toserver, afs_int32 topart, afs_uint32 tovolid,
                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
@@ -5144,7 +5144,7 @@ UV_RestoreVolume2(afs_uint32 toserver, afs_int32 topart, afs_uint32 tovolid,
                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,
@@ -5300,7 +5300,7 @@ UV_AddSite2(afs_uint32 server, afs_int32 part, afs_uint32 volid,
 
     /* 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) {
@@ -5350,9 +5350,9 @@ UV_AddSite2(afs_uint32 server, afs_int32 part, afs_uint32 volid,
     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++;
 
@@ -5426,8 +5426,8 @@ UV_RemoveSite(afs_uint32 server, afs_int32 part, afs_uint32 volid)
     } 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);
@@ -6008,8 +6008,8 @@ CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver, afs_int32 apart,
        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");
@@ -6036,7 +6036,7 @@ CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver, afs_int32 apart,
            } 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);
@@ -6062,7 +6062,7 @@ CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver, afs_int32 apart,
                        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);
@@ -6100,14 +6100,14 @@ CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver, afs_int32 apart,
        }
 
        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);
@@ -6165,7 +6165,7 @@ CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver, afs_int32 apart,
                    }
                } 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]) {
@@ -6208,13 +6208,13 @@ CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver, afs_int32 apart,
            }
        }
        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++;
        }
@@ -6232,7 +6232,7 @@ CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver, afs_int32 apart,
                entry.nServers++;
                addvolume++;
            } else {
-               if (!(entry.flags & RO_EXISTS)) {
+               if (!(entry.flags & VLF_ROEXISTS)) {
                    addvolume++;
                }
            }
@@ -6246,7 +6246,7 @@ CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver, afs_int32 apart,
            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++;
@@ -6257,7 +6257,7 @@ CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver, afs_int32 apart,
                 * 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);
@@ -6316,13 +6316,13 @@ CheckVolume(volintInfo * volumeinfo, afs_uint32 aserver, afs_int32 apart,
        }
 
        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++;
        }
@@ -6475,8 +6475,8 @@ UV_SyncVolume(afs_uint32 aserver, afs_int32 apart, char *avolname, int flags)
        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");
@@ -6842,12 +6842,12 @@ CheckVldbRWBK(struct nvldbentry * entry, afs_int32 * 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 {
@@ -6855,18 +6855,18 @@ CheckVldbRWBK(struct nvldbentry * entry, afs_int32 * modified)
            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",
@@ -6880,12 +6880,12 @@ CheckVldbRWBK(struct nvldbentry * entry, afs_int32 * modified)
        }
     }
 
-    /* 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 */
@@ -6894,18 +6894,18 @@ CheckVldbRWBK(struct nvldbentry * entry, afs_int32 * modified)
                         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",
@@ -6922,8 +6922,8 @@ CheckVldbRWBK(struct nvldbentry * entry, afs_int32 * modified)
     /* 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--;
@@ -6948,11 +6948,11 @@ CheckVldbRO(struct nvldbentry *entry, afs_int32 * modified)
     if (modified)
        *modified = 0;
 
-    /* Check to see if the RO volumes exist and set the RO_EXISTS
+    /* 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 */
        }
 
@@ -6980,13 +6980,13 @@ CheckVldbRO(struct nvldbentry *entry, afs_int32 * modified)
     }
 
     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++;
        }
     }
@@ -7016,8 +7016,8 @@ CheckVldb(struct nvldbentry * entry, afs_int32 * modified, afs_int32 * deleted)
     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");
     }
@@ -7080,8 +7080,8 @@ CheckVldb(struct nvldbentry * entry, afs_int32 * modified, afs_int32 * deleted)
        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],
@@ -7291,7 +7291,7 @@ UV_RenameVolume(struct nvldbentry *entry, char oldname[], char newname[])
     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
      * 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,
@@ -7341,7 +7341,7 @@ UV_RenameVolume(struct nvldbentry *entry, char oldname[], char newname[])
        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,
@@ -7398,9 +7398,9 @@ UV_RenameVolume(struct nvldbentry *entry, char oldname[], char newname[])
     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_retry(aconn, entry->volumeId[ROVOL],