AFSFid fid;
int tlen;
cm_req_t req;
+ struct rx_connection * callp;
cm_InitReq(&req);
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);
long code;
AFSFid fid;
cm_req_t req;
+ struct rx_connection * callp;
cm_InitReq(&req);
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);
char *cp;
cm_cell_t *cellp;
cm_req_t req;
+ struct rx_connection * callp;
cm_InitReq(&req);
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);
char *OfflineMsg;
char *MOTD;
cm_req_t req;
+ struct rx_connection * callp;
cm_InitReq(&req);
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);
int sflags;
AFSFetchStatus newDirStatus;
AFSVolSync volSync;
+ struct rx_connection * callp;
#ifdef AFS_FREELANCE_CLIENT
if (cm_freelanceEnabled && dscp == cm_rootSCachep) {
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);
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);
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);
cm_conn_t *connp;
AFSFid tfid;
AFSStoreStatus afsInStatus;
+ struct rx_connection * callp;
/* handle file length setting */
if (attrp->mask & CM_ATTRMASK_LENGTH)
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);
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.
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);
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.
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);
AFSFetchStatus updatedDirStatus;
AFSFetchStatus newLinkStatus;
AFSVolSync volSync;
+ struct rx_connection * callp;
if (dscp->fid.cell != sscp->fid.cell ||
dscp->fid.volume != sscp->fid.volume) {
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));
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
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);
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
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);
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
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);
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.
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);
int anotherReader = 0;
int smallLock = 0;
int found = 0;
+ struct rx_connection * callp;
if (LargeIntegerLessThan(LLength, scp->length))
smallLock = 1;
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);
AFSVolSync volSync;
cm_conn_t *connp;
long code;
+ struct rx_connection * callp;
cm_InitReq(&req);
&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));
osi_queue_t *q;
cm_req_t req;
int found = 0;
+ struct rx_connection * callp;
if (vcp_is_dead) {
code = CM_ERROR_TIMEDOUT;
&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));