cm_callbackRequest_t cbr;
int mustCall;
cm_fid_t sfid;
- struct rx_connection * callp = NULL;
+ struct rx_connection * rxconnp = NULL;
int syncop_done = 0;
osi_Log4(afsd_logp, "GetCallback scp 0x%p cell %d vol %d flags %lX",
if (code)
continue;
- callp = cm_GetRxConn(connp);
- code = RXAFS_FetchStatus(callp, &tfid,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_FetchStatus(rxconnp, &tfid,
&afsStatus, &callback, &volSync);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp, &sfid, &volSync, NULL,
&cbr, code));
osi_hyper_t thyper;
AFSVolSync volSync;
AFSFid tfid;
- struct rx_call *callp;
+ struct rx_call *rxcallp;
struct rx_connection *rxconnp;
osi_queueData_t *qdp;
cm_buf_t *bufp;
retry:
rxconnp = cm_GetRxConn(connp);
- callp = rx_NewCall(rxconnp);
+ rxcallp = rx_NewCall(rxconnp);
rx_PutConnection(rxconnp);
#ifdef AFS_LARGEFILES
osi_Log4(afsd_logp, "CALL StartRXAFS_StoreData64 scp 0x%p, offset 0x%x:%08x, length 0x%x",
scp, biod.offset.HighPart, biod.offset.LowPart, nbytes);
- code = StartRXAFS_StoreData64(callp, &tfid, &inStatus,
+ code = StartRXAFS_StoreData64(rxcallp, &tfid, &inStatus,
biod.offset.QuadPart,
nbytes,
truncPos.QuadPart);
osi_Log4(afsd_logp, "CALL StartRXAFS_StoreData scp 0x%p, offset 0x%x:%08x, length 0x%x",
scp, biod.offset.HighPart, biod.offset.LowPart, nbytes);
- code = StartRXAFS_StoreData(callp, &tfid, &inStatus,
+ code = StartRXAFS_StoreData(rxcallp, &tfid, &inStatus,
biod.offset.LowPart, nbytes, truncPos.LowPart);
if (code)
osi_Log1(afsd_logp, "CALL StartRXAFS_StoreData FAILURE, code 0x%x", code);
osi_Log4(afsd_logp, "CALL StartRXAFS_StoreData scp 0x%p, offset 0x%x:%08x, length 0x%x",
scp, biod.offset.HighPart, biod.offset.LowPart, nbytes);
- code = StartRXAFS_StoreData(callp, &tfid, &inStatus,
+ code = StartRXAFS_StoreData(rxcallp, &tfid, &inStatus,
biod.offset.LowPart, nbytes, truncPos.LowPart);
if (code)
osi_Log1(afsd_logp, "CALL StartRXAFS_StoreData FAILURE, code 0x%x", code);
wbytes = cm_data.buf_blockSize;
/* write out wbytes of data from bufferp */
- temp = rx_Write(callp, bufferp, wbytes);
+ temp = rx_Write(rxcallp, bufferp, wbytes);
if (temp != wbytes) {
osi_Log3(afsd_logp, "rx_Write failed bp 0x%p, %d != %d",bufp,temp,wbytes);
code = -1;
if (code == 0) {
if (SERVERHAS64BIT(connp)) {
- code = EndRXAFS_StoreData64(callp, &outStatus, &volSync);
+ code = EndRXAFS_StoreData64(rxcallp, &outStatus, &volSync);
if (code)
osi_Log2(afsd_logp, "EndRXAFS_StoreData64 FAILURE scp 0x%p code %lX", scp, code);
else
osi_Log0(afsd_logp, "EndRXAFS_StoreData64 SUCCESS");
} else {
- code = EndRXAFS_StoreData(callp, &outStatus, &volSync);
+ code = EndRXAFS_StoreData(rxcallp, &outStatus, &volSync);
if (code)
osi_Log2(afsd_logp, "EndRXAFS_StoreData FAILURE scp 0x%p code %lX",scp,code);
else
}
}
- code = rx_EndCall(callp, code);
+ code = rx_EndCall(rxcallp, code);
#ifdef AFS_LARGEFILES
if (code == RXGEN_OPCODE && SERVERHAS64BIT(connp)) {
long code;
osi_hyper_t truncPos;
cm_conn_t *connp;
- struct rx_call *callp;
+ struct rx_call *rxcallp;
struct rx_connection *rxconnp;
int require_64bit_ops = 0;
retry:
rxconnp = cm_GetRxConn(connp);
- callp = rx_NewCall(rxconnp);
+ rxcallp = rx_NewCall(rxconnp);
rx_PutConnection(rxconnp);
#ifdef AFS_LARGEFILES
if (SERVERHAS64BIT(connp)) {
- code = StartRXAFS_StoreData64(callp, &tfid, &inStatus,
+ code = StartRXAFS_StoreData64(rxcallp, &tfid, &inStatus,
0, 0, truncPos.QuadPart);
} else {
if (require_64bit_ops) {
code = CM_ERROR_TOOBIG;
} else {
- code = StartRXAFS_StoreData(callp, &tfid, &inStatus,
+ code = StartRXAFS_StoreData(rxcallp, &tfid, &inStatus,
0, 0, truncPos.LowPart);
}
}
#else
- code = StartRXAFS_StoreData(callp, &tfid, &inStatus,
+ code = StartRXAFS_StoreData(rxcallp, &tfid, &inStatus,
0, 0, truncPos.LowPart);
#endif
if (code == 0) {
if (SERVERHAS64BIT(connp))
- code = EndRXAFS_StoreData64(callp, &outStatus, &volSync);
+ code = EndRXAFS_StoreData64(rxcallp, &outStatus, &volSync);
else
- code = EndRXAFS_StoreData(callp, &outStatus, &volSync);
+ code = EndRXAFS_StoreData(rxcallp, &outStatus, &volSync);
}
- code = rx_EndCall(callp, code);
+ code = rx_EndCall(rxcallp, code);
#ifdef AFS_LARGEFILES
if (code == RXGEN_OPCODE && SERVERHAS64BIT(connp)) {
cm_buf_t *tbufp; /* buf we're filling */
osi_queueData_t *qdp; /* q element we're scanning */
AFSFid tfid;
- struct rx_call *callp;
+ struct rx_call *rxcallp;
struct rx_connection *rxconnp;
cm_bulkIO_t biod; /* bulk IO descriptor */
cm_conn_t *connp;
continue;
rxconnp = cm_GetRxConn(connp);
- callp = rx_NewCall(rxconnp);
+ rxcallp = rx_NewCall(rxconnp);
rx_PutConnection(rxconnp);
#ifdef AFS_LARGEFILES
osi_Log4(afsd_logp, "CALL FetchData64 scp 0x%p, off 0x%x:%08x, size 0x%x",
scp, biod.offset.HighPart, biod.offset.LowPart, biod.length);
- code = StartRXAFS_FetchData64(callp, &tfid, biod.offset.QuadPart, biod.length);
+ code = StartRXAFS_FetchData64(rxcallp, &tfid, biod.offset.QuadPart, biod.length);
if (code == 0) {
- temp = rx_Read(callp, (char *) &nbytes_hi, sizeof(afs_int32));
+ temp = rx_Read(rxcallp, (char *) &nbytes_hi, sizeof(afs_int32));
if (temp == sizeof(afs_int32)) {
nbytes_hi = ntohl(nbytes_hi);
} else {
nbytes_hi = 0;
- code = callp->error;
- rx_EndCall(callp, code);
- callp = NULL;
+ code = rxcallp->error;
+ rx_EndCall(rxcallp, code);
+ rxcallp = NULL;
}
}
}
osi_Log0(afsd_logp, "Skipping FetchData. Operation requires FetchData64");
code = CM_ERROR_TOOBIG;
} else {
- if (!callp) {
+ if (!rxcallp) {
rxconnp = cm_GetRxConn(connp);
- callp = rx_NewCall(rxconnp);
+ rxcallp = rx_NewCall(rxconnp);
rx_PutConnection(rxconnp);
}
osi_Log3(afsd_logp, "CALL FetchData scp 0x%p, off 0x%x, size 0x%x",
scp, biod.offset.LowPart, biod.length);
- code = StartRXAFS_FetchData(callp, &tfid, biod.offset.LowPart,
+ code = StartRXAFS_FetchData(rxcallp, &tfid, biod.offset.LowPart,
biod.length);
SET_SERVERHASNO64BIT(connp);
}
if (code == 0) {
- temp = rx_Read(callp, (char *)&nbytes, sizeof(afs_int32));
+ temp = rx_Read(rxcallp, (char *)&nbytes, sizeof(afs_int32));
if (temp == sizeof(afs_int32)) {
nbytes = ntohl(nbytes);
FillInt64(length_found, nbytes_hi, nbytes);
if (length_found > biod.length)
- code = (callp->error < 0) ? callp->error : -1;
+ code = (rxcallp->error < 0) ? rxcallp->error : -1;
} else {
- code = (callp->error < 0) ? callp->error : -1;
+ code = (rxcallp->error < 0) ? rxcallp->error : -1;
}
}
/* for the moment, nbytes_hi will always be 0 if code == 0
osi_Log3(afsd_logp, "CALL FetchData scp 0x%p, off 0x%x, size 0x%x",
scp, biod.offset.LowPart, biod.length);
- code = StartRXAFS_FetchData(callp, &tfid, biod.offset.LowPart,
+ code = StartRXAFS_FetchData(rxcallp, &tfid, biod.offset.LowPart,
biod.length);
/* now copy the data out of the pipe and put it in the buffer */
if (code == 0) {
- temp = rx_Read(callp, (char *)&nbytes, sizeof(afs_int32));
+ temp = rx_Read(rxcallp, (char *)&nbytes, sizeof(afs_int32));
if (temp == sizeof(afs_int32)) {
nbytes = ntohl(nbytes);
if (nbytes > biod.length)
- code = (callp->error < 0) ? callp->error : -1;
+ code = (rxcallp->error < 0) ? rxcallp->error : -1;
}
else
- code = (callp->error < 0) ? callp->error : -1;
+ code = (rxcallp->error < 0) ? rxcallp->error : -1;
}
#endif
/* read rbytes of data */
rbytes = (nbytes > cm_data.buf_blockSize? cm_data.buf_blockSize : nbytes);
- temp = rx_Read(callp, bufferp, rbytes);
+ temp = rx_Read(rxcallp, bufferp, rbytes);
if (temp < rbytes) {
- code = (callp->error < 0) ? callp->error : -1;
+ code = (rxcallp->error < 0) ? rxcallp->error : -1;
break;
}
if (code == 0) {
if (SERVERHAS64BIT(connp))
- code = EndRXAFS_FetchData64(callp, &afsStatus, &callback, &volSync);
+ code = EndRXAFS_FetchData64(rxcallp, &afsStatus, &callback, &volSync);
else
- code = EndRXAFS_FetchData(callp, &afsStatus, &callback, &volSync);
+ code = EndRXAFS_FetchData(rxcallp, &afsStatus, &callback, &volSync);
} else {
if (SERVERHAS64BIT(connp))
osi_Log1(afsd_logp, "CALL EndRXAFS_FetchData64 skipped due to error %d", code);
osi_Log1(afsd_logp, "CALL EndRXAFS_FetchData skipped due to error %d", code);
}
- if (callp)
- code = rx_EndCall(callp, code);
+ if (rxcallp)
+ code = rx_EndCall(rxcallp, code);
if (code == RXKADUNKNOWNKEY)
osi_Log0(afsd_logp, "CALL EndCall returns RXKADUNKNOWNKEY");
AFSVolSync volSync;
AFSFid afid;
int tlen;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
/* now make the get acl call */
#ifdef AFS_FREELANCE_CLIENT
if (code)
continue;
- callp = cm_GetRxConn(connp);
- code = RXAFS_FetchACL(callp, &afid, &acl, &fileStatus, &volSync);
- rx_PutConnection(callp);
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_FetchACL(rxconnp, &afid, &acl, &fileStatus, &volSync);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
AFSFetchStatus fileStatus;
AFSVolSync volSync;
AFSFid fid;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
#ifdef AFS_FREELANCE_CLIENT
if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
if (code)
continue;
- callp = cm_GetRxConn(connp);
- code = RXAFS_StoreACL(callp, &fid, &acl, &fileStatus, &volSync);
- rx_PutConnection(callp);
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_StoreACL(rxconnp, &fid, &acl, &fileStatus, &volSync);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
cm_cell_t *cellp;
char *cp;
clientchar_t *strp;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
#ifdef AFS_FREELANCE_CLIENT
if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
if (code)
continue;
- callp = cm_GetRxConn(tcp);
- code = RXAFS_SetVolumeStatus(callp, scp->fid.volume,
+ rxconnp = cm_GetRxConn(tcp);
+ code = RXAFS_SetVolumeStatus(rxconnp, scp->fid.volume,
&storeStat, volName, offLineMsg, motd);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(tcp, userp, reqp, &scp->fid, NULL, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
char *Name;
char *OfflineMsg;
char *MOTD;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
#ifdef AFS_FREELANCE_CLIENT
if ( scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID ) {
code = cm_ConnFromFID(&scp->fid, userp, reqp, &connp);
if (code) continue;
- callp = cm_GetRxConn(connp);
- code = RXAFS_GetVolumeStatus(callp, scp->fid.volume,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_GetVolumeStatus(rxconnp, scp->fid.volume,
&volStat, &Name, &OfflineMsg, &MOTD);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp, &scp->fid, NULL, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
int sflags;
AFSFetchStatus newDirStatus;
AFSVolSync volSync;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
cm_dirOp_t dirop;
cm_scache_t *scp = NULL;
int free_fnamep = FALSE;
if (code)
continue;
- callp = cm_GetRxConn(connp);
- code = RXAFS_RemoveFile(callp, &afsFid, fnamep,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_RemoveFile(rxconnp, &afsFid, fnamep,
&newDirStatus, &volSync);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} 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;
+ struct rx_connection * rxconnp;
int inlinebulk = 0; /* Did we use InlineBulkStatus RPC or not? */
/* otherwise, we may have one or more bulk stat's worth of stuff in bb;
if (code)
continue;
- callp = cm_GetRxConn(connp);
+ rxconnp = cm_GetRxConn(connp);
if (!(connp->serverp->flags & CM_SERVERFLAG_NOINLINEBULK)) {
- code = RXAFS_InlineBulkStatus(callp, &fidStruct,
+ code = RXAFS_InlineBulkStatus(rxconnp, &fidStruct,
&statStruct, &callbackStruct, &volSync);
if (code == RXGEN_OPCODE) {
cm_SetServerNoInlineBulk(connp->serverp, 0);
}
}
if (!inlinebulk) {
- code = RXAFS_BulkStatus(callp, &fidStruct,
+ code = RXAFS_BulkStatus(rxconnp, &fidStruct,
&statStruct, &callbackStruct, &volSync);
}
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp, &dscp->fid,
&volSync, NULL, &cbReq, code));
cm_conn_t *connp;
AFSFid tfid;
AFSStoreStatus afsInStatus;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
/* handle file length setting */
if (attrp->mask & CM_ATTRMASK_LENGTH)
if (code)
continue;
- callp = cm_GetRxConn(connp);
- code = RXAFS_StoreStatus(callp, &tfid,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_StoreStatus(rxconnp, &tfid,
&afsInStatus, &afsOutStatus, &volSync);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
&scp->fid, &volSync, NULL, NULL, code));
AFSFetchStatus newFileStatus;
AFSCallBack newFileCallback;
AFSVolSync volSync;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
cm_dirOp_t dirop;
fschar_t * fnamep = NULL;
dirAFSFid.Vnode = dscp->fid.vnode;
dirAFSFid.Unique = dscp->fid.unique;
- callp = cm_GetRxConn(connp);
- code = RXAFS_CreateFile(connp->callp, &dirAFSFid, fnamep,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_CreateFile(connp->rxconnp, &dirAFSFid, fnamep,
&inStatus, &newAFSFid, &newFileStatus,
&updatedDirStatus, &newFileCallback,
&volSync);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
&dscp->fid, &volSync, NULL, &cbReq, code));
AFSFetchStatus newDirStatus;
AFSCallBack newDirCallback;
AFSVolSync volSync;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
cm_dirOp_t dirop;
fschar_t * fnamep = NULL;
dirAFSFid.Vnode = dscp->fid.vnode;
dirAFSFid.Unique = dscp->fid.unique;
- callp = cm_GetRxConn(connp);
- code = RXAFS_MakeDir(connp->callp, &dirAFSFid, fnamep,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_MakeDir(connp->rxconnp, &dirAFSFid, fnamep,
&inStatus, &newAFSFid, &newDirStatus,
&updatedDirStatus, &newDirCallback,
&volSync);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
&dscp->fid, &volSync, NULL, &cbReq, code));
AFSFetchStatus updatedDirStatus;
AFSFetchStatus newLinkStatus;
AFSVolSync volSync;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
cm_dirOp_t dirop;
fschar_t * fnamep = NULL;
existingAFSFid.Vnode = sscp->fid.vnode;
existingAFSFid.Unique = sscp->fid.unique;
- callp = cm_GetRxConn(connp);
- code = RXAFS_Link(callp, &dirAFSFid, fnamep, &existingAFSFid,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_Link(rxconnp, &dirAFSFid, fnamep, &existingAFSFid,
&newLinkStatus, &updatedDirStatus, &volSync);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
osi_Log1(afsd_logp," RXAFS_Link returns 0x%x", code);
} while (cm_Analyze(connp, userp, reqp,
AFSFetchStatus updatedDirStatus;
AFSFetchStatus newLinkStatus;
AFSVolSync volSync;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
cm_dirOp_t dirop;
fschar_t *fnamep = NULL;
dirAFSFid.Vnode = dscp->fid.vnode;
dirAFSFid.Unique = dscp->fid.unique;
- callp = cm_GetRxConn(connp);
- code = RXAFS_Symlink(callp, &dirAFSFid, fnamep, contentsp,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_Symlink(rxconnp, &dirAFSFid, fnamep, contentsp,
&inStatus, &newAFSFid, &newLinkStatus,
&updatedDirStatus, &volSync);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
&dscp->fid, &volSync, NULL, NULL, code));
int didEnd;
AFSFetchStatus updatedDirStatus;
AFSVolSync volSync;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
cm_dirOp_t dirop;
cm_scache_t *scp = NULL;
int free_fnamep = FALSE;
dirAFSFid.Vnode = dscp->fid.vnode;
dirAFSFid.Unique = dscp->fid.unique;
- callp = cm_GetRxConn(connp);
- code = RXAFS_RemoveDir(callp, &dirAFSFid, fnamep,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_RemoveDir(rxconnp, &dirAFSFid, fnamep,
&updatedDirStatus, &volSync);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
&dscp->fid, &volSync, NULL, NULL, code));
AFSFetchStatus updatedNewDirStatus;
AFSVolSync volSync;
int oneDir;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
cm_dirOp_t oldDirOp;
cm_fid_t fileFid;
int diropCode = -1;
newDirAFSFid.Vnode = newDscp->fid.vnode;
newDirAFSFid.Unique = newDscp->fid.unique;
- callp = cm_GetRxConn(connp);
- code = RXAFS_Rename(callp, &oldDirAFSFid, oldNamep,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_Rename(rxconnp, &oldDirAFSFid, oldNamep,
&newDirAFSFid, newNamep,
&updatedOldDirStatus, &updatedNewDirStatus,
&volSync);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp, &oldDscp->fid,
&volSync, NULL, NULL, code));
AFSFid tfid;
cm_fid_t cfid;
cm_conn_t * connp;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
AFSVolSync volSync;
afs_uint32 reqflags = reqp->flags;
if (code)
break;
- callp = cm_GetRxConn(connp);
- code = RXAFS_SetLock(callp, &tfid, lockType,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_SetLock(rxconnp, &tfid, lockType,
&volSync);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp, &cfid, &volSync,
NULL, NULL, code));
AFSFid tfid;
cm_fid_t cfid;
cm_conn_t * connp;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
AFSVolSync volSync;
tfid.Volume = scp->fid.volume;
if (code)
break;
- callp = cm_GetRxConn(connp);
- code = RXAFS_ReleaseLock(callp, &tfid, &volSync);
- rx_PutConnection(callp);
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_ReleaseLock(rxconnp, &tfid, &volSync);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp, &cfid, &volSync,
NULL, NULL, code));
AFSVolSync volSync;
cm_conn_t *connp;
long code;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
cm_scache_t * scp;
cm_InitReq(&req);
if (code)
break;
- callp = cm_GetRxConn(connp);
- code = RXAFS_ExtendLock(callp, &tfid,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_ExtendLock(rxconnp, &tfid,
&volSync);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
osi_Log1(afsd_logp, " ExtendLock returns %d", code);
char *OfflineMsg;
char *MOTD;
cm_req_t req;
- struct rx_connection * callp;
+ struct rx_connection * rxconnp;
char volName[32];
char offLineMsg[256];
char motd[256];
if (code)
continue;
- callp = cm_GetRxConn(connp);
- code = RXAFS_GetVolumeStatus(callp, volp->vol[RWVOL].ID,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_GetVolumeStatus(rxconnp, volp->vol[RWVOL].ID,
&volStat, &Name, &OfflineMsg, &MOTD);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, cm_rootUserp, &req, NULL, NULL, NULL, NULL, code));
code = cm_MapRPCError(code, &req);
if (code)
continue;
- callp = cm_GetRxConn(connp);
- code = RXAFS_GetVolumeStatus(callp, volp->vol[ROVOL].ID,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_GetVolumeStatus(rxconnp, volp->vol[ROVOL].ID,
&volStat, &Name, &OfflineMsg, &MOTD);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, cm_rootUserp, &req, NULL, NULL, NULL, NULL, code));
code = cm_MapRPCError(code, &req);
if (code)
continue;
- callp = cm_GetRxConn(connp);
- code = RXAFS_GetVolumeStatus(callp, volp->vol[BACKVOL].ID,
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_GetVolumeStatus(rxconnp, volp->vol[BACKVOL].ID,
&volStat, &Name, &OfflineMsg, &MOTD);
- rx_PutConnection(callp);
+ rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, cm_rootUserp, &req, NULL, NULL, NULL, NULL, code));
code = cm_MapRPCError(code, &req);