rx-refcount-20041012
authorJeffrey Altman <jaltman@mit.edu>
Wed, 13 Oct 2004 03:30:49 +0000 (03:30 +0000)
committerJeffrey Altman <jaltman@secure-endpoints.com>
Wed, 13 Oct 2004 03:30:49 +0000 (03:30 +0000)
FIXES 15585

 * use new rx_GetConnection/rx_PutConnection functions to increment/
   decrement the refCounts on the rx_connection objects so that the
   objects are not invalidated during RXAFS_xxx calls when:

    - the user tokens change
    - the global cryptlevel changes

 * import SysName from registry and parse along white space boundaries

src/WINNT/afsd/afsd_init.c
src/WINNT/afsd/cm_callback.c
src/WINNT/afsd/cm_conn.c
src/WINNT/afsd/cm_conn.h
src/WINNT/afsd/cm_dcache.c
src/WINNT/afsd/cm_ioctl.c
src/WINNT/afsd/cm_server.c
src/WINNT/afsd/cm_vnodeops.c

index 92e5617..a11118b 100644 (file)
@@ -373,7 +373,7 @@ int afsd_InitCM(char **reasonP)
     static struct rx_securityClass *nullServerSecurityClassp;
     struct hostent *thp;
     char *msgBuf;
-    char buf[200];
+    char buf[1024];
     HKEY parmKey;
     DWORD dummyLen;
     DWORD regType;
@@ -645,15 +645,37 @@ int afsd_InitCM(char **reasonP)
     }
     cm_sysName = cm_sysNameList[0];
 
-    dummyLen = MAXSYSNAME;
-    code = RegQueryValueEx(parmKey, "SysName", NULL, NULL, cm_sysName, &dummyLen);
-    if (code == ERROR_SUCCESS)
-        afsi_log("Sys name %s", cm_sysName);
-    else {
+    dummyLen = sizeof(buf);
+    code = RegQueryValueEx(parmKey, "SysName", NULL, NULL, buf, &dummyLen);
+    if (code == ERROR_SUCCESS && buf[0]) {
+        char * p, *q; 
+        afsi_log("Sys name %s", buf);
+
+        for (p = q = buf; p < cm_sysName + dummyLen; p++)
+        {
+            if (*p == '\0' || isspace(*p)) {
+                memcpy(cm_sysNameList[cm_sysNameCount],q,p-q);
+                cm_sysNameList[cm_sysNameCount][p-q] = '\0';
+                cm_sysNameCount++;
+
+                do {
+                    if (*p == '\0')
+                        goto done_sysname;
+                        
+                    p++;
+                } while (*p == '\0' || isspace(*p));
+                q = p;
+                p--;
+            }
+        }
+      done_sysname:
+        StringCbCopyA(cm_sysName, MAXSYSNAME, cm_sysNameList[0]);
+    } else {
+        cm_sysNameCount = 1;
         StringCbCopyA(cm_sysName, MAXSYSNAME, "i386_nt40");
+        StringCbCopyA(cm_sysNameList[0], MAXSYSNAME, "i386_nt40");
         afsi_log("Default sys name %s", cm_sysName);
     }
-    cm_sysNameCount = 1;
 
     dummyLen = sizeof(cryptall);
     code = RegQueryValueEx(parmKey, "SecurityLevel", NULL, NULL,
index 3f77df2..14dac42 100644 (file)
@@ -808,6 +808,7 @@ long cm_GetCallback(cm_scache_t *scp, struct cm_user *userp,
     int mustCall;
     long sflags;
     cm_fid_t sfid;
+    struct rx_connection * callp;
 
     osi_Log2(afsd_logp, "GetCallback scp %x flags %lX", scp, flags);
 
@@ -871,10 +872,11 @@ long cm_GetCallback(cm_scache_t *scp, struct cm_user *userp,
             code = cm_Conn(&sfid, userp, reqp, &connp);
             if (code) continue;
 
-            lock_ObtainMutex(&connp->mx);
-            code = RXAFS_FetchStatus(connp->callp, &tfid,
+            callp = cm_GetRxConn(connp);
+            code = RXAFS_FetchStatus(callp, &tfid,
                                      &afsStatus, &callback, &volSync);
-            lock_ReleaseMutex(&connp->mx);
+            rx_PutConnection(callp);
+
         } while (cm_Analyze(connp, userp, reqp, &sfid, &volSync, NULL,
                             &cbr, code));
         code = cm_MapRPCError(code, reqp);
index b0ac57f..32e748a 100644 (file)
@@ -565,7 +565,7 @@ long cm_ConnByServer(cm_server_t *serverp, cm_user_t *userp, cm_conn_t **connpp)
         tcp->refCount = 1;
         lock_ReleaseMutex(&tcp->mx);
     } else {
-        if ((tcp->ucgen < ucellp->gen) || 
+        if ((tcp->ucgen < ucellp->gen) ||
             (tcp->cryptlevel != (cryptall ? rxkad_crypt : rxkad_clear)))
         {
             lock_ObtainMutex(&tcp->mx);
@@ -602,3 +602,15 @@ long cm_Conn(struct cm_fid *fidp, struct cm_user *userp, cm_req_t *reqp,
     cm_FreeServerList(serverspp);
     return code;
 }
+
+extern struct rx_connection * 
+cm_GetRxConn(cm_conn_t *connp)
+{
+    struct rx_connection * rxconn;
+    lock_ObtainMutex(&connp->mx);
+    rxconn = connp->callp;
+    rx_GetConnection(rxconn);
+    lock_ReleaseMutex(&connp->mx);
+    return rxconn;
+}
+
index 6f2f2e3..701561d 100644 (file)
@@ -83,6 +83,7 @@ typedef struct cm_req {
                                   cache managers treat it as "server is down"*/
 
 #include "cm_server.h"
+#include "rx.h"
 
 extern void cm_InitConn(void);
 
@@ -106,4 +107,6 @@ extern void cm_PutConn(cm_conn_t *connp);
 
 extern void cm_GCConnections(cm_server_t *serverp);
 
+extern struct rx_connection * cm_GetRxConn(cm_conn_t *connp);
+
 #endif /*  __CM_CONN_H_ENV__ */
index 40f3cb4..550fa22 100644 (file)
@@ -129,12 +129,13 @@ long cm_BufWrite(void *vfidp, osi_hyper_t *offsetp, long length, long flags,
         if (code) 
             continue;
                
+        lock_ObtainMutex(&connp->mx);
         callp = rx_NewCall(connp->callp);
+        lock_ReleaseMutex(&connp->mx);
 
         osi_Log3(afsd_logp, "CALL StoreData vp %x, off 0x%x, size 0x%x",
                  (long) scp, biod.offset.LowPart, nbytes);
 
-        lock_ObtainMutex(&connp->mx);
         code = StartRXAFS_StoreData(callp, &tfid, &inStatus,
                                     biod.offset.LowPart, nbytes, truncPos);
 
@@ -174,8 +175,6 @@ long cm_BufWrite(void *vfidp, osi_hyper_t *offsetp, long length, long flags,
                 osi_Log1(afsd_logp, "EndRXAFS_StoreData failed (%lX)",code);
         }
         code = rx_EndCall(callp, code);
-        lock_ReleaseMutex(&connp->mx);
-
         osi_Log0(afsd_logp, "CALL StoreData DONE");
                 
     } while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync, NULL, NULL, code));
@@ -263,9 +262,10 @@ long cm_StoreMini(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
         if (code) 
             continue;
                
+        lock_ObtainMutex(&connp->mx);
         callp = rx_NewCall(connp->callp);
+        lock_ReleaseMutex(&connp->mx);
 
-        lock_ObtainMutex(&connp->mx);
         code = StartRXAFS_StoreData(callp, &tfid, &inStatus,
                                     0, 0, truncPos);
 
@@ -273,8 +273,6 @@ long cm_StoreMini(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
             code = EndRXAFS_StoreData(callp, &outStatus, &volSync);
         code = rx_EndCall(callp, code);
 
-        lock_ReleaseMutex(&connp->mx);
-
     } while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync, NULL, NULL, code));
     code = cm_MapRPCError(code, reqp);
         
@@ -1241,6 +1239,7 @@ long cm_GetBuffer(cm_scache_t *scp, cm_buf_t *bufp, int *cpffp, cm_user_t *up,
                
         lock_ObtainMutex(&connp->mx);
         callp = rx_NewCall(connp->callp);
+        lock_ReleaseMutex(&connp->mx);
 
         osi_Log3(afsd_logp, "CALL FetchData vp %x, off 0x%x, size 0x%x",
                   (long) scp, biod.offset.LowPart, biod.length);
@@ -1353,8 +1352,6 @@ long cm_GetBuffer(cm_scache_t *scp, cm_buf_t *bufp, int *cpffp, cm_user_t *up,
             osi_Log0(afsd_logp, "CALL EndCall returns RXKADUNKNOWNKEY");
         osi_Log0(afsd_logp, "CALL FetchData DONE");
 
-        lock_ReleaseMutex(&connp->mx);
-
     } while (cm_Analyze(connp, up, reqp, &scp->fid, &volSync, NULL, NULL, code));
 
   fetchingcompleted:
index 2922d17..13bd7a4 100644 (file)
@@ -411,6 +411,7 @@ long cm_IoctlGetACL(smb_ioctl_t *ioctlp, cm_user_t *userp)
     AFSFid fid;
     int tlen;
     cm_req_t req;
+    struct rx_connection * callp;
 
     cm_InitReq(&req);
 
@@ -427,9 +428,10 @@ long cm_IoctlGetACL(smb_ioctl_t *ioctlp, cm_user_t *userp)
         code = cm_Conn(&scp->fid, userp, &req, &connp);
         if (code) continue;
 
-        lock_ObtainMutex(&connp->mx);
-        code = RXAFS_FetchACL(connp->callp, &fid, &acl, &fileStatus, &volSync);
-        lock_ReleaseMutex(&connp->mx);
+        callp = cm_GetRxConn(connp);
+        code = RXAFS_FetchACL(callp, &fid, &acl, &fileStatus, &volSync);
+        rx_PutConnection(callp);
+
     } while (cm_Analyze(connp, userp, &req, &scp->fid, &volSync, NULL, NULL, code));
     code = cm_MapRPCError(code, &req);
     cm_ReleaseSCache(scp);
@@ -478,6 +480,7 @@ long cm_IoctlSetACL(struct smb_ioctl *ioctlp, struct cm_user *userp)
     long code;
     AFSFid fid;
     cm_req_t req;
+    struct rx_connection * callp;
 
     cm_InitReq(&req);
 
@@ -494,9 +497,10 @@ long cm_IoctlSetACL(struct smb_ioctl *ioctlp, struct cm_user *userp)
         code = cm_Conn(&scp->fid, userp, &req, &connp);
         if (code) continue;
 
-        lock_ObtainMutex(&connp->mx);
-        code = RXAFS_StoreACL(connp->callp, &fid, &acl, &fileStatus, &volSync);
-        lock_ReleaseMutex(&connp->mx);
+        callp = cm_GetRxConn(connp);
+        code = RXAFS_StoreACL(callp, &fid, &acl, &fileStatus, &volSync);
+        rx_PutConnection(callp);
+
     } while (cm_Analyze(connp, userp, &req, &scp->fid, &volSync, NULL, NULL, code));
     code = cm_MapRPCError(code, &req);
 
@@ -578,6 +582,7 @@ long cm_IoctlSetVolumeStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
     char *cp;
     cm_cell_t *cellp;
     cm_req_t req;
+    struct rx_connection * callp;
 
     cm_InitReq(&req);
 
@@ -621,10 +626,11 @@ long cm_IoctlSetVolumeStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
         code = cm_Conn(&scp->fid, userp, &req, &tcp);
         if (code) continue;
 
-        lock_ObtainMutex(&tcp->mx);
-        code = RXAFS_SetVolumeStatus(tcp->callp, scp->fid.volume,
+        callp = cm_GetRxConn(tcp);
+        code = RXAFS_SetVolumeStatus(callp, scp->fid.volume,
                                       &storeStat, volName, offLineMsg, motd);
-        lock_ReleaseMutex(&tcp->mx);
+        rx_PutConnection(callp);
+
     } while (cm_Analyze(tcp, userp, &req, &scp->fid, NULL, NULL, NULL, code));
     code = cm_MapRPCError(code, &req);
 
@@ -668,6 +674,7 @@ long cm_IoctlGetVolumeStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
     char *OfflineMsg;
     char *MOTD;
     cm_req_t req;
+    struct rx_connection * callp;
 
     cm_InitReq(&req);
 
@@ -681,10 +688,11 @@ long cm_IoctlGetVolumeStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
         code = cm_Conn(&scp->fid, userp, &req, &tcp);
         if (code) continue;
 
-        lock_ObtainMutex(&tcp->mx);
-        code = RXAFS_GetVolumeStatus(tcp->callp, scp->fid.volume,
+        callp = cm_GetRxConn(tcp);
+        code = RXAFS_GetVolumeStatus(callp, scp->fid.volume,
                                       &volStat, &Name, &OfflineMsg, &MOTD);
-        lock_ReleaseMutex(&tcp->mx);
+        rx_PutConnection(callp);
+
     } while (cm_Analyze(tcp, userp, &req, &scp->fid, NULL, NULL, NULL, code));
     code = cm_MapRPCError(code, &req);
 
index c6af94d..fa2eb85 100644 (file)
@@ -50,6 +50,7 @@ void cm_CheckServers(long flags, cm_cell_t *cellp)
     long now;
     int wasDown;
     cm_conn_t *connp;
+    struct rx_connection * callp;
 
     lock_ObtainWrite(&cm_serverLock);
     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
@@ -95,9 +96,9 @@ void cm_CheckServers(long flags, cm_cell_t *cellp)
                 }
                 else {
                     /* file server */
-                    lock_ObtainMutex(&connp->mx);
-                    code = RXAFS_GetTime(connp->callp, &secs, &usecs);
-                    lock_ReleaseMutex(&connp->mx);
+                    callp = cm_GetRxConn(connp);
+                    code = RXAFS_GetTime(callp, &secs, &usecs);
+                    rx_PutConnection(callp);
                 }
                 if (wasDown)
                     rx_SetConnDeadTime(connp->callp, ConnDeadtimeout);
index bd01179..1751144 100644 (file)
@@ -1128,6 +1128,7 @@ long cm_Unlink(cm_scache_t *dscp, char *namep, cm_user_t *userp, cm_req_t *reqp)
     int sflags;
     AFSFetchStatus newDirStatus;
     AFSVolSync volSync;
+    struct rx_connection * callp;
 
 #ifdef AFS_FREELANCE_CLIENT
     if (cm_freelanceEnabled && dscp == cm_rootSCachep) {
@@ -1154,10 +1155,11 @@ long cm_Unlink(cm_scache_t *dscp, char *namep, cm_user_t *userp, cm_req_t *reqp)
         if (code) 
             continue;
 
-        lock_ObtainMutex(&connp->mx);
-        code = RXAFS_RemoveFile(connp->callp, &afsFid, namep,
+        callp = cm_GetRxConn(connp);
+        code = RXAFS_RemoveFile(callp, &afsFid, namep,
                                  &newDirStatus, &volSync);
-        lock_ReleaseMutex(&connp->mx);
+        rx_PutConnection(callp);
+
     } while (cm_Analyze(connp, userp, reqp, &dscp->fid, &volSync, NULL, NULL, code));
     code = cm_MapRPCError(code, reqp);
 
@@ -1647,6 +1649,7 @@ void cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
     long j;
     cm_scache_t *scp;
     cm_fid_t tfid;
+    struct rx_connection * callp;
 
     osi_Log1(afsd_logp, "cm_TryBulkStat dir 0x%x", (long) dscp);
 
@@ -1685,10 +1688,11 @@ void cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
             if (code) 
                 continue;
 
-            lock_ObtainMutex(&connp->mx);
-            code = RXAFS_BulkStatus(connp->callp, &fidStruct,
+            callp = cm_GetRxConn(connp);
+            code = RXAFS_BulkStatus(callp, &fidStruct,
                                      &statStruct, &callbackStruct, &volSync);
-            lock_ReleaseMutex(&connp->mx);
+            rx_PutConnection(callp);
+
         } while (cm_Analyze(connp, userp, reqp, &dscp->fid,
                              &volSync, NULL, &cbReq, code));
         code = cm_MapRPCError(code, reqp);
@@ -1884,6 +1888,7 @@ long cm_SetAttr(cm_scache_t *scp, cm_attr_t *attrp, cm_user_t *userp,
     cm_conn_t *connp;
     AFSFid tfid;
     AFSStoreStatus afsInStatus;
+    struct rx_connection * callp;
 
     /* handle file length setting */
     if (attrp->mask & CM_ATTRMASK_LENGTH)
@@ -1912,10 +1917,11 @@ long cm_SetAttr(cm_scache_t *scp, cm_attr_t *attrp, cm_user_t *userp,
         if (code) 
             continue;
 
-        lock_ObtainMutex(&connp->mx);
-        code = RXAFS_StoreStatus(connp->callp, &tfid,
+        callp = cm_GetRxConn(connp);
+        code = RXAFS_StoreStatus(callp, &tfid,
                                   &afsInStatus, &afsOutStatus, &volSync);
-        lock_ReleaseMutex(&connp->mx);
+        rx_PutConnection(callp);
+
     } while (cm_Analyze(connp, userp, reqp,
                          &scp->fid, &volSync, NULL, NULL, code));
     code = cm_MapRPCError(code, reqp);
@@ -1952,6 +1958,7 @@ long cm_Create(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp,
     AFSFetchStatus newFileStatus;
     AFSCallBack newFileCallback;
     AFSVolSync volSync;
+    struct rx_connection * callp;
 
     /* can't create names with @sys in them; must expand it manually first.
      * return "invalid request" if they try.
@@ -1986,12 +1993,14 @@ long cm_Create(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp,
         dirAFSFid.Volume = dscp->fid.volume;
         dirAFSFid.Vnode = dscp->fid.vnode;
         dirAFSFid.Unique = dscp->fid.unique;
-        lock_ObtainMutex(&connp->mx);
+
+        callp = cm_GetRxConn(connp);
         code = RXAFS_CreateFile(connp->callp, &dirAFSFid, namep,
                                  &inStatus, &newAFSFid, &newFileStatus,
                                  &updatedDirStatus, &newFileCallback,
                                  &volSync);
-        lock_ReleaseMutex(&connp->mx);
+        rx_PutConnection(callp);
+
     } while (cm_Analyze(connp, userp, reqp,
                          &dscp->fid, &volSync, NULL, &cbReq, code));
     code = cm_MapRPCError(code, reqp);
@@ -2071,6 +2080,7 @@ long cm_MakeDir(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp,
     AFSFetchStatus newDirStatus;
     AFSCallBack newDirCallback;
     AFSVolSync volSync;
+    struct rx_connection * callp;
 
     /* can't create names with @sys in them; must expand it manually first.
      * return "invalid request" if they try.
@@ -2105,12 +2115,14 @@ long cm_MakeDir(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp,
         dirAFSFid.Volume = dscp->fid.volume;
         dirAFSFid.Vnode = dscp->fid.vnode;
         dirAFSFid.Unique = dscp->fid.unique;
-        lock_ObtainMutex(&connp->mx);
+
+        callp = cm_GetRxConn(connp);
         code = RXAFS_MakeDir(connp->callp, &dirAFSFid, namep,
                               &inStatus, &newAFSFid, &newDirStatus,
                               &updatedDirStatus, &newDirCallback,
                               &volSync);
-        lock_ReleaseMutex(&connp->mx);
+        rx_PutConnection(callp);
+
     } while (cm_Analyze(connp, userp, reqp,
                          &dscp->fid, &volSync, NULL, &cbReq, code));
     code = cm_MapRPCError(code, reqp);
@@ -2165,6 +2177,7 @@ long cm_Link(cm_scache_t *dscp, char *namep, cm_scache_t *sscp, long flags,
     AFSFetchStatus updatedDirStatus;
     AFSFetchStatus newLinkStatus;
     AFSVolSync volSync;
+    struct rx_connection * callp;
 
     if (dscp->fid.cell != sscp->fid.cell ||
         dscp->fid.volume != sscp->fid.volume) {
@@ -2190,12 +2203,12 @@ long cm_Link(cm_scache_t *dscp, char *namep, cm_scache_t *sscp, long flags,
         existingAFSFid.Vnode = sscp->fid.vnode;
         existingAFSFid.Unique = sscp->fid.unique;
 
-        lock_ObtainMutex(&connp->mx);
-        code = RXAFS_Link(connp->callp, &dirAFSFid, namep, &existingAFSFid,
+        callp = cm_GetRxConn(connp);
+        code = RXAFS_Link(callp, &dirAFSFid, namep, &existingAFSFid,
             &newLinkStatus, &updatedDirStatus, &volSync);
-        lock_ReleaseMutex(&connp->mx);
-
+        rx_PutConnection(callp);
         osi_Log1(smb_logp,"  RXAFS_Link returns %d", code);
+
     } while (cm_Analyze(connp, userp, reqp,
         &dscp->fid, &volSync, NULL, NULL, code));
 
@@ -2224,6 +2237,7 @@ long cm_SymLink(cm_scache_t *dscp, char *namep, char *contentsp, long flags,
     AFSFetchStatus updatedDirStatus;
     AFSFetchStatus newLinkStatus;
     AFSVolSync volSync;
+    struct rx_connection * callp;
 
     /* before starting the RPC, mark that we're changing the directory data,
      * so that someone who does a chmod on the dir will wait until our
@@ -2247,11 +2261,13 @@ long cm_SymLink(cm_scache_t *dscp, char *namep, char *contentsp, long flags,
         dirAFSFid.Volume = dscp->fid.volume;
         dirAFSFid.Vnode = dscp->fid.vnode;
         dirAFSFid.Unique = dscp->fid.unique;
-        lock_ObtainMutex(&connp->mx);
-        code = RXAFS_Symlink(connp->callp, &dirAFSFid, namep, contentsp,
+
+        callp = cm_GetRxConn(connp);
+        code = RXAFS_Symlink(callp, &dirAFSFid, namep, contentsp,
                               &inStatus, &newAFSFid, &newLinkStatus,
                               &updatedDirStatus, &volSync);
-        lock_ReleaseMutex(&connp->mx);
+        rx_PutConnection(callp);
+
     } while (cm_Analyze(connp, userp, reqp,
                          &dscp->fid, &volSync, NULL, NULL, code));
     code = cm_MapRPCError(code, reqp);
@@ -2298,6 +2314,7 @@ long cm_RemoveDir(cm_scache_t *dscp, char *namep, cm_user_t *userp,
     int didEnd;
     AFSFetchStatus updatedDirStatus;
     AFSVolSync volSync;
+    struct rx_connection * callp;
 
     /* before starting the RPC, mark that we're changing the directory data,
      * so that someone who does a chmod on the dir will wait until our
@@ -2320,10 +2337,12 @@ long cm_RemoveDir(cm_scache_t *dscp, char *namep, cm_user_t *userp,
         dirAFSFid.Volume = dscp->fid.volume;
         dirAFSFid.Vnode = dscp->fid.vnode;
         dirAFSFid.Unique = dscp->fid.unique;
-        lock_ObtainMutex(&connp->mx);
-        code = RXAFS_RemoveDir(connp->callp, &dirAFSFid, namep,
+
+        callp = cm_GetRxConn(connp);
+        code = RXAFS_RemoveDir(callp, &dirAFSFid, namep,
                                 &updatedDirStatus, &volSync);
-        lock_ReleaseMutex(&connp->mx);
+        rx_PutConnection(callp);
+
     } while (cm_Analyze(connp, userp, reqp,
                          &dscp->fid, &volSync, NULL, NULL, code));
     code = cm_MapRPCErrorRmdir(code, reqp);
@@ -2370,6 +2389,7 @@ long cm_Rename(cm_scache_t *oldDscp, char *oldNamep, cm_scache_t *newDscp,
     AFSFetchStatus updatedNewDirStatus;
     AFSVolSync volSync;
     int oneDir;
+    struct rx_connection * callp;
 
     /* before starting the RPC, mark that we're changing the directory data,
      * so that someone who does a chmod on the dir will wait until our call
@@ -2461,12 +2481,14 @@ long cm_Rename(cm_scache_t *oldDscp, char *oldNamep, cm_scache_t *newDscp,
         newDirAFSFid.Volume = newDscp->fid.volume;
         newDirAFSFid.Vnode = newDscp->fid.vnode;
         newDirAFSFid.Unique = newDscp->fid.unique;
-        lock_ObtainMutex(&connp->mx);
-        code = RXAFS_Rename(connp->callp, &oldDirAFSFid, oldNamep,
+
+        callp = cm_GetRxConn(connp);
+        code = RXAFS_Rename(callp, &oldDirAFSFid, oldNamep,
                              &newDirAFSFid, newNamep,
                              &updatedOldDirStatus, &updatedNewDirStatus,
                              &volSync);
-        lock_ReleaseMutex(&connp->mx);
+        rx_PutConnection(callp);
+
     } while (cm_Analyze(connp, userp, reqp, &oldDscp->fid,
                          &volSync, NULL, NULL, code));
     code = cm_MapRPCError(code, reqp);
@@ -2508,6 +2530,7 @@ long cm_Lock(cm_scache_t *scp, unsigned char LockType,
     cm_file_lock_t *fileLock;
     osi_queue_t *q;
     int found = 0;
+    struct rx_connection * callp;
 
     /* Look for a conflict.  Also, if we are asking for a shared lock,
      * look for another shared lock, so we don't have to do an RPC.
@@ -2538,10 +2561,12 @@ long cm_Lock(cm_scache_t *scp, unsigned char LockType,
             code = cm_Conn(&scp->fid, userp, reqp, &connp);
             if (code) 
                 break;
-            lock_ObtainMutex(&connp->mx);
-            code = RXAFS_SetLock(connp->callp, &tfid, Which,
+
+            callp = cm_GetRxConn(connp);
+            code = RXAFS_SetLock(callp, &tfid, Which,
                                   &volSync);
-            lock_ReleaseMutex(&connp->mx);
+            rx_PutConnection(callp);
+
         } while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync,
                              NULL, NULL, code));
         lock_ObtainMutex(&scp->mx);
@@ -2581,6 +2606,7 @@ long cm_Unlock(cm_scache_t *scp, unsigned char LockType,
     int anotherReader = 0;
     int smallLock = 0;
     int found = 0;
+    struct rx_connection * callp;
 
     if (LargeIntegerLessThan(LLength, scp->length))
         smallLock = 1;
@@ -2633,9 +2659,11 @@ long cm_Unlock(cm_scache_t *scp, unsigned char LockType,
             code = cm_Conn(&scp->fid, userp, reqp, &connp);
             if (code) 
                 break;
-            lock_ObtainMutex(&connp->mx);
-            code = RXAFS_ReleaseLock(connp->callp, &tfid, &volSync);
-            lock_ReleaseMutex(&connp->mx);
+
+            callp = cm_GetRxConn(connp);
+            code = RXAFS_ReleaseLock(callp, &tfid, &volSync);
+            rx_PutConnection(callp);
+
         } while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync,
                              NULL, NULL, code));
         code = cm_MapRPCError(code, reqp);
@@ -2654,6 +2682,7 @@ void cm_CheckLocks()
     AFSVolSync volSync;
     cm_conn_t *connp;
     long code;
+    struct rx_connection * callp;
 
     cm_InitReq(&req);
 
@@ -2676,10 +2705,12 @@ void cm_CheckLocks()
                                 &req, &connp);
                 if (code) 
                     break;
-                lock_ObtainMutex(&connp->mx);
-                code = RXAFS_ExtendLock(connp->callp, &tfid,
+
+                callp = cm_GetRxConn(connp);
+                code = RXAFS_ExtendLock(callp, &tfid,
                                          &volSync);
-                lock_ReleaseMutex(&connp->mx);
+                rx_PutConnection(callp);
+
             } while (cm_Analyze(connp, fileLock->userp, &req,
                                  &fileLock->fid, &volSync, NULL, NULL,
                                  code));
@@ -2703,6 +2734,7 @@ long cm_RetryLock(cm_file_lock_t *oldFileLock, int vcp_is_dead)
     osi_queue_t *q;
     cm_req_t req;
     int found = 0;
+    struct rx_connection * callp;
 
     if (vcp_is_dead) {
         code = CM_ERROR_TIMEDOUT;
@@ -2746,10 +2778,12 @@ long cm_RetryLock(cm_file_lock_t *oldFileLock, int vcp_is_dead)
                             &req, &connp);
             if (code) 
                 break;
-            lock_ObtainMutex(&connp->mx);
-            code = RXAFS_SetLock(connp->callp, &tfid, Which,
+
+            callp = cm_GetRxConn(connp);
+            code = RXAFS_SetLock(callp, &tfid, Which,
                                   &volSync);
-            lock_ReleaseMutex(&connp->mx);
+            rx_PutConnection(callp);
+
         } while (cm_Analyze(connp, oldFileLock->userp, &req,
                              &oldFileLock->fid, &volSync,
                              NULL, NULL, code));