#include <rx/rx.h>
#include <rx/rxkad.h>
#include <afs/unified_afs.h>
+#include <afs/vlserver.h>
#include <WINNT/afsreg.h>
osi_rwlock_t cm_connLock;
DWORD RDRtimeout = CM_CONN_DEFAULTRDRTIMEOUT;
unsigned short ConnDeadtimeout = CM_CONN_CONNDEADTIME;
unsigned short HardDeadtimeout = CM_CONN_HARDDEADTIME;
+unsigned short IdleDeadtimeout = CM_CONN_IDLEDEADTIME;
#define LANMAN_WKS_PARAM_KEY "SYSTEM\\CurrentControlSet\\Services\\lanmanworkstation\\parameters"
#define LANMAN_WKS_SESSION_TIMEOUT "SessTimeout"
void cm_PutConn(cm_conn_t *connp)
{
- lock_ObtainWrite(&cm_connLock);
- osi_assertx(connp->refCount-- > 0, "cm_conn_t refcount 0");
- lock_ReleaseWrite(&cm_connLock);
+ afs_int32 refCount = InterlockedDecrement(&connp->refCount);
+ osi_assertx(refCount >= 0, "cm_conn_t refcount underflow");
}
void cm_InitConn(void)
HKEY parmKey;
if (osi_Once(&once)) {
- lock_InitializeRWLock(&cm_connLock, "connection global lock");
+ lock_InitializeRWLock(&cm_connLock, "connection global lock",
+ LOCK_HIERARCHY_CONN_GLOBAL);
/* keisa - read timeout value for lanmanworkstation service.
* jaltman - as per
dummyLen = sizeof(DWORD);
code = RegQueryValueEx(parmKey, "ConnDeadTimeout", NULL, NULL,
(BYTE *) &dwValue, &dummyLen);
- if (code == ERROR_SUCCESS)
+ if (code == ERROR_SUCCESS) {
ConnDeadtimeout = (unsigned short)dwValue;
-
+ afsi_log("ConnDeadTimeout is %d", ConnDeadtimeout);
+ }
dummyLen = sizeof(DWORD);
code = RegQueryValueEx(parmKey, "HardDeadTimeout", NULL, NULL,
(BYTE *) &dwValue, &dummyLen);
- if (code == ERROR_SUCCESS)
+ if (code == ERROR_SUCCESS) {
HardDeadtimeout = (unsigned short)dwValue;
- afsi_log("HardDeadTimeout is %d", HardDeadtimeout);
- RegCloseKey(parmKey);
+ afsi_log("HardDeadTimeout is %d", HardDeadtimeout);
+ }
+ dummyLen = sizeof(DWORD);
+ code = RegQueryValueEx(parmKey, "IdleDeadTimeout", NULL, NULL,
+ (BYTE *) &dwValue, &dummyLen);
+ if (code == ERROR_SUCCESS) {
+ IdleDeadtimeout = (unsigned short)dwValue;
+ afsi_log("IdleDeadTimeout is %d", IdleDeadtimeout);
+ }
+ RegCloseKey(parmKey);
}
afsi_log("lanmanworkstation : SessTimeout %u", RDRtimeout);
- if (ConnDeadtimeout == 0)
+ if (ConnDeadtimeout == 0) {
ConnDeadtimeout = (unsigned short) (RDRtimeout / 2);
- afsi_log("ConnDeadTimeout is %d", ConnDeadtimeout);
- if (HardDeadtimeout == 0)
+ afsi_log("ConnDeadTimeout is %d", ConnDeadtimeout);
+ }
+ if (HardDeadtimeout == 0) {
HardDeadtimeout = (unsigned short) RDRtimeout;
- afsi_log("HardDeadTimeout is %d", HardDeadtimeout);
-
+ afsi_log("HardDeadTimeout is %d", HardDeadtimeout);
+ }
+ if (ConnDeadtimeout == 0) {
+ IdleDeadtimeout = (unsigned short) RDRtimeout;
+ afsi_log("IdleDeadTimeout is %d", IdleDeadtimeout);
+ }
osi_EndOnce(&once);
}
}
if (!cellp)
return CM_ERROR_NOSUCHCELL;
- code = cm_GetVolumeByID(cellp, fidp->volume, userp, reqp, CM_GETVOL_FLAG_CREATE, &volp);
+ code = cm_FindVolumeByID(cellp, fidp->volume, userp, reqp, CM_GETVOL_FLAG_CREATE, &volp);
if (code)
return code;
*serversppp = cm_GetVolServers(volp, fidp->volume);
+ lock_ObtainRead(&cm_volumeLock);
cm_PutVolume(volp);
+ lock_ReleaseRead(&cm_volumeLock);
return 0;
}
int dead_session;
long timeUsed, timeLeft;
long code;
- char addr[16];
+ char addr[16]="unknown";
int forcing_new = 0;
osi_Log2(afsd_logp, "cm_Analyze connp 0x%p, code 0x%x",
else if (errorCode == CM_ERROR_ALLDOWN) {
osi_Log0(afsd_logp, "cm_Analyze passed CM_ERROR_ALLDOWN.");
/* Servers marked DOWN will be restored by the background daemon
- * thread as they become available.
+ * thread as they become available. The volume status is
+ * updated as the server state changes.
*/
}
/* Volume instances marked offline will be restored by the
* background daemon thread as they become available
*/
- if (timeLeft > 7 && fidp) {
- thrd_Sleep(5000);
-
- code = cm_GetVolumeByID(cellp, fidp->volume, userp, reqp,
- CM_GETVOL_FLAG_NO_LRU_UPDATE,
- &volp);
+ if (fidp) {
+ code = cm_FindVolumeByID(cellp, fidp->volume, userp, reqp,
+ CM_GETVOL_FLAG_NO_LRU_UPDATE,
+ &volp);
if (code == 0) {
- if (fidp->volume == volp->rw.ID)
- statep = &volp->rw;
- else if (fidp->volume == volp->ro.ID)
- statep = &volp->ro;
- else if (fidp->volume == volp->bk.ID)
- statep = &volp->bk;
-
- if (statep->state != vl_offline && statep->state != vl_unknown) {
- retry = 1;
- } else {
- if (cm_CheckOfflineVolume(volp, statep->ID))
+ if (timeLeft > 7) {
+ thrd_Sleep(5000);
+
+ /* cm_CheckOfflineVolume() resets the serverRef state */
+ if (cm_CheckOfflineVolume(volp, fidp->volume))
retry = 1;
+ } else {
+ cm_UpdateVolumeStatus(volp, fidp->volume);
}
-
+ lock_ObtainRead(&cm_volumeLock);
cm_PutVolume(volp);
+ lock_ReleaseRead(&cm_volumeLock);
+ volp = NULL;
}
- }
+ }
}
else if (errorCode == CM_ERROR_ALLBUSY) {
/* Volumes that are busy cannot be determined to be non-busy
* without actually attempting to access them.
*/
osi_Log0(afsd_logp, "cm_Analyze passed CM_ERROR_ALLBUSY.");
- if (timeLeft > 7) {
-
- thrd_Sleep(5000);
-
- if (fidp) { /* File Server query */
- code = cm_GetVolumeByID(cellp, fidp->volume, userp, reqp,
- CM_GETVOL_FLAG_NO_LRU_UPDATE,
- &volp);
- if (code == 0) {
- if (fidp->volume == volp->rw.ID)
- statep = &volp->rw;
- else if (fidp->volume == volp->ro.ID)
- statep = &volp->ro;
- else if (fidp->volume == volp->bk.ID)
- statep = &volp->bk;
+ if (fidp) { /* File Server query */
+ code = cm_FindVolumeByID(cellp, fidp->volume, userp, reqp,
+ CM_GETVOL_FLAG_NO_LRU_UPDATE,
+ &volp);
+ if (code == 0) {
+ if (timeLeft > 7) {
+ thrd_Sleep(5000);
+
+ statep = cm_VolumeStateByID(volp, fidp->volume);
if (statep->state != vl_offline &&
- statep->state != vl_busy &&
- statep->state != vl_unknown) {
+ statep->state != vl_busy &&
+ statep->state != vl_unknown) {
retry = 1;
} else {
if (!serversp) {
for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
if (tsrp->status == srv_busy) {
tsrp->status = srv_not_busy;
- }
+ }
}
lock_ReleaseWrite(&cm_serverLock);
if (free_svr_list) {
*serverspp = serversp;
}
- cm_UpdateVolumeStatus(volp, statep->ID);
+ cm_UpdateVolumeStatus(volp, fidp->volume);
retry = 1;
}
-
- cm_PutVolume(volp);
+ } else {
+ cm_UpdateVolumeStatus(volp, fidp->volume);
}
- } else { /* VL Server query */
+
+ lock_ObtainRead(&cm_volumeLock);
+ cm_PutVolume(volp);
+ lock_ReleaseRead(&cm_volumeLock);
+ volp = NULL;
+ }
+ } else { /* VL Server query */
+ if (timeLeft > 7) {
+ thrd_Sleep(5000);
+
if (serversp) {
lock_ObtainWrite(&cm_serverLock);
for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
if (tsrp->server == serverp && tsrp->status == srv_not_busy) {
tsrp->status = srv_busy;
if (fidp) { /* File Server query */
- code = cm_GetVolumeByID(cellp, fidp->volume, userp, reqp,
+ lock_ReleaseWrite(&cm_serverLock);
+ code = cm_FindVolumeByID(cellp, fidp->volume, userp, reqp,
CM_GETVOL_FLAG_NO_LRU_UPDATE,
&volp);
- if (code == 0) {
- if (fidp->volume == volp->rw.ID)
- statep = &volp->rw;
- else if (fidp->volume == volp->ro.ID)
- statep = &volp->ro;
- else if (fidp->volume == volp->bk.ID)
- statep = &volp->bk;
- }
+ if (code == 0)
+ statep = cm_VolumeStateByID(volp, fidp->volume);
+ lock_ObtainWrite(&cm_serverLock);
}
break;
}
if (statep) {
cm_UpdateVolumeStatus(volp, statep->ID);
+ lock_ObtainRead(&cm_volumeLock);
cm_PutVolume(volp);
+ lock_ReleaseRead(&cm_volumeLock);
+ volp = NULL;
}
if (free_svr_list) {
}
if (fidp) { /* File Server query */
- code = cm_GetVolumeByID(cellp, fidp->volume, userp, reqp,
+ lock_ReleaseWrite(&cm_serverLock);
+ code = cm_FindVolumeByID(cellp, fidp->volume, userp, reqp,
CM_GETVOL_FLAG_NO_LRU_UPDATE,
&volp);
- if (code == 0) {
- if (fidp->volume == volp->rw.ID)
- statep = &volp->rw;
- else if (fidp->volume == volp->ro.ID)
- statep = &volp->ro;
- else if (fidp->volume == volp->bk.ID)
- statep = &volp->bk;
- }
+ if (code == 0)
+ cm_VolumeStateByID(volp, fidp->volume);
+ lock_ObtainWrite(&cm_serverLock);
}
}
}
if (statep) {
cm_UpdateVolumeStatus(volp, statep->ID);
+ lock_ObtainRead(&cm_volumeLock);
cm_PutVolume(volp);
+ lock_ReleaseRead(&cm_volumeLock);
+ volp = NULL;
}
if (free_svr_list) {
if (scp->fileType != CM_SCACHETYPE_DIRECTORY)
pscp = cm_FindSCacheParent(scp);
-
- lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&scp->rw);
lock_ObtainWrite(&cm_scacheLock);
cm_RemoveSCacheFromHashTable(scp);
lock_ReleaseWrite(&cm_scacheLock);
cm_LockMarkSCacheLost(scp);
scp->flags |= CM_SCACHEFLAG_DELETED;
- lock_ReleaseMutex(&scp->mx);
+ lock_ReleaseWrite(&scp->rw);
cm_ReleaseSCache(scp);
if (pscp) {
if (cm_HaveCallback(pscp)) {
- lock_ObtainMutex(&pscp->mx);
+ lock_ObtainWrite(&pscp->rw);
cm_DiscardSCache(pscp);
- lock_ReleaseMutex(&pscp->mx);
+ lock_ReleaseWrite(&pscp->rw);
}
cm_ReleaseSCache(pscp);
}
* In addition, we log an event to the event log
*/
+ if (serverp) {
/* Log server being offline for this volume */
sprintf(addr, "%d.%d.%d.%d",
((serverp->addr.sin_addr.s_addr & 0xff)),
LogEvent(EVENTLOG_WARNING_TYPE, MSG_RX_HARD_DEAD_TIME_EXCEEDED, addr);
- retry = 0;
osi_Log1(afsd_logp, "cm_Analyze: hardDeadTime exceeded addr[%s]",
osi_LogSaveString(afsd_logp,addr));
+ reqp->tokenIdleErrorServp = serverp;
+ reqp->idleError++;
+ retry = 1;
+ }
}
else if (errorCode >= -64 && errorCode < 0) {
/* mark server as down */
if ( timeLeft > 2 )
retry = 1;
}
+ } else if (errorCode >= ERROR_TABLE_BASE_RXK && errorCode < ERROR_TABLE_BASE_RXK + 256) {
+ if (serverp) {
+ reqp->tokenIdleErrorServp = serverp;
+ reqp->tokenError = errorCode;
+ retry = 1;
+ }
} else if (errorCode == VICECONNBAD || errorCode == VICETOKENDEAD) {
cm_ForceNewConnections(serverp);
if ( timeLeft > 2 )
case UAEACCES : s = "UAEACCES"; break;
case ENOENT : s = "ENOENT"; break;
case UAENOENT : s = "UAENOENT"; break;
+ case EEXIST : s = "EEXIST"; break;
+ case UAEEXIST : s = "UAEEXIST"; break;
case VICECONNBAD : s = "VICECONNBAD"; break;
case VICETOKENDEAD : s = "VICETOKENDEAD"; break;
case WSAEWOULDBLOCK : s = "WSAEWOULDBLOCK"; break;
case UAEWOULDBLOCK : s = "UAEWOULDBLOCK"; break;
+ case VL_IDEXIST : s = "VL_IDEXIST"; break;
+ case VL_IO : s = "VL_IO"; break;
+ case VL_NAMEEXIST : s = "VL_NAMEEXIST"; break;
+ case VL_CREATEFAIL : s = "VL_CREATEFAIL"; break;
+ case VL_NOENT : s = "VL_NOENT"; break;
+ case VL_EMPTY : s = "VL_EMPTY"; break;
+ case VL_ENTDELETED : s = "VL_ENTDELETED"; break;
+ case VL_BADNAME : s = "VL_BADNAME"; break;
+ case VL_BADINDEX : s = "VL_BADINDEX"; break;
+ case VL_BADVOLTYPE : s = "VL_BADVOLTYPE"; break;
+ case VL_BADSERVER : s = "VL_BADSERVER"; break;
+ case VL_BADPARTITION : s = "VL_BADPARTITION"; break;
+ case VL_REPSFULL : s = "VL_REPSFULL"; break;
+ case VL_NOREPSERVER : s = "VL_NOREPSERVER"; break;
+ case VL_DUPREPSERVER : s = "VL_DUPREPSERVER"; break;
+ case VL_RWNOTFOUND : s = "VL_RWNOTFOUND"; break;
+ case VL_BADREFCOUNT : s = "VL_BADREFCOUNT"; break;
+ case VL_SIZEEXCEEDED : s = "VL_SIZEEXCEEDED"; break;
+ case VL_BADENTRY : s = "VL_BADENTRY"; break;
+ case VL_BADVOLIDBUMP : s = "VL_BADVOLIDBUMP"; break;
+ case VL_IDALREADYHASHED: s = "VL_IDALREADYHASHED"; break;
+ case VL_ENTRYLOCKED : s = "VL_ENTRYLOCKED"; break;
+ case VL_BADVOLOPER : s = "VL_BADVOLOPER"; break;
+ case VL_BADRELLOCKTYPE : s = "VL_BADRELLOCKTYPE"; break;
+ case VL_RERELEASE : s = "VL_RERELEASE"; break;
+ case VL_BADSERVERFLAG : s = "VL_BADSERVERFLAG"; break;
+ case VL_PERM : s = "VL_PERM"; break;
+ case VL_NOMEM : s = "VL_NOMEM"; break;
+ case VL_BADVERSION : s = "VL_BADVERSION"; break;
+ case VL_INDEXERANGE : s = "VL_INDEXERANGE"; break;
+ case VL_MULTIPADDR : s = "VL_MULTIPADDR"; break;
+ case VL_BADMASK : s = "VL_BADMASK"; break;
case CM_ERROR_NOSUCHCELL : s = "CM_ERROR_NOSUCHCELL"; break;
case CM_ERROR_NOSUCHVOLUME : s = "CM_ERROR_NOSUCHVOLUME"; break;
case CM_ERROR_TIMEDOUT : s = "CM_ERROR_TIMEDOUT"; break;
cm_server_t *tsp;
long firstError = 0;
int someBusy = 0, someOffline = 0, allOffline = 1, allBusy = 1, allDown = 1;
+#ifdef SET_RX_TIMEOUTS_TO_TIMELEFT
long timeUsed, timeLeft, hardTimeLeft;
-
+#endif
*connpp = NULL;
if (serversp == NULL) {
return CM_ERROR_ALLDOWN;
}
+#ifdef SET_RX_TIMEOUTS_TO_TIMELEFT
timeUsed = (GetTickCount() - reqp->startTime) / 1000;
/* leave 5 seconds margin of safety */
timeLeft = ConnDeadtimeout - timeUsed - 5;
hardTimeLeft = HardDeadtimeout - timeUsed - 5;
+#endif
- lock_ObtainWrite(&cm_serverLock);
+ lock_ObtainRead(&cm_serverLock);
for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
tsp = tsrp->server;
- cm_GetServerNoLock(tsp);
- lock_ReleaseWrite(&cm_serverLock);
- if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
- allDown = 0;
- if (tsrp->status == srv_deleted) {
- /* skip this entry. no longer valid. */;
- } else if (tsrp->status == srv_busy) {
- allOffline = 0;
- someBusy = 1;
- } else if (tsrp->status == srv_offline) {
- allBusy = 0;
- someOffline = 1;
- } else {
- allOffline = 0;
- allBusy = 0;
- code = cm_ConnByServer(tsp, usersp, connpp);
- if (code == 0) { /* cm_CBS only returns 0 */
- cm_PutServer(tsp);
- /* Set RPC timeout */
- if (timeLeft > ConnDeadtimeout)
- timeLeft = ConnDeadtimeout;
-
- if (hardTimeLeft > HardDeadtimeout)
- hardTimeLeft = HardDeadtimeout;
-
- lock_ObtainMutex(&(*connpp)->mx);
- rx_SetConnDeadTime((*connpp)->callp, timeLeft);
- rx_SetConnHardDeadTime((*connpp)->callp, (u_short) hardTimeLeft);
- lock_ReleaseMutex(&(*connpp)->mx);
- return 0;
+ if (reqp->tokenIdleErrorServp) {
+ /*
+ * search the list until we find the server
+ * that failed last time. When we find it
+ * clear the error, skip it and try the one
+ * in the list.
+ */
+ if (tsp == reqp->tokenIdleErrorServp)
+ reqp->tokenIdleErrorServp = NULL;
+ continue;
+ }
+ if (tsp) {
+ cm_GetServerNoLock(tsp);
+ lock_ReleaseRead(&cm_serverLock);
+ if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
+ allDown = 0;
+ if (tsrp->status == srv_deleted) {
+ /* skip this entry. no longer valid. */;
+ } else if (tsrp->status == srv_busy) {
+ allOffline = 0;
+ someBusy = 1;
+ } else if (tsrp->status == srv_offline) {
+ allBusy = 0;
+ someOffline = 1;
+ } else {
+ allOffline = 0;
+ allBusy = 0;
+ code = cm_ConnByServer(tsp, usersp, connpp);
+ if (code == 0) { /* cm_CBS only returns 0 */
+ cm_PutServer(tsp);
+#ifdef SET_RX_TIMEOUTS_TO_TIMELEFT
+ /* Set RPC timeout */
+ if (timeLeft > ConnDeadtimeout)
+ timeLeft = ConnDeadtimeout;
+
+ if (hardTimeLeft > HardDeadtimeout)
+ hardTimeLeft = HardDeadtimeout;
+
+ lock_ObtainMutex(&(*connpp)->mx);
+ rx_SetConnDeadTime((*connpp)->rxconnp, timeLeft);
+ rx_SetConnHardDeadTime((*connpp)->rxconnp, (u_short) hardTimeLeft);
+ lock_ReleaseMutex(&(*connpp)->mx);
+#endif
+ return 0;
+ }
+
+ /* therefore, this code is never executed */
+ if (firstError == 0)
+ firstError = code;
}
-
- /* therefore, this code is never executed */
- if (firstError == 0)
- firstError = code;
}
+ lock_ObtainRead(&cm_serverLock);
+ cm_PutServerNoLock(tsp);
}
- lock_ObtainWrite(&cm_serverLock);
- cm_PutServerNoLock(tsp);
}
- lock_ReleaseWrite(&cm_serverLock);
+ lock_ReleaseRead(&cm_serverLock);
if (firstError == 0) {
if (allDown)
- firstError = CM_ERROR_ALLDOWN;
+ firstError = (reqp->tokenError ? reqp->tokenError :
+ (reqp->idleError ? RX_CALL_TIMEOUT : CM_ERROR_ALLDOWN));
else if (allBusy)
firstError = CM_ERROR_ALLBUSY;
else if (allOffline || (someBusy && someOffline))
cm_PutServer(tcp->serverp);
cm_ReleaseUser(userp);
*lcpp = tcp->nextp;
- rx_DestroyConnection(tcp->callp);
+ rx_DestroyConnection(tcp->rxconnp);
lock_FinalizeMutex(&tcp->mx);
free(tcp);
}
}
if (ucellp->flags & CM_UCELLFLAG_RXKAD) {
secIndex = 2;
- if (cryptall) {
- tcp->cryptlevel = rxkad_crypt;
- } else {
+ switch (cryptall) {
+ case 0:
tcp->cryptlevel = rxkad_clear;
+ break;
+ case 2:
+ tcp->cryptlevel = rxkad_auth;
+ break;
+ default:
+ tcp->cryptlevel = rxkad_crypt;
}
secObjp = rxkad_NewClientSecurityObject(tcp->cryptlevel,
&ucellp->sessionKey, ucellp->kvno,
secObjp = rxnull_NewClientSecurityObject();
}
osi_assertx(secObjp != NULL, "null rx_securityClass");
- tcp->callp = rx_NewConnection(serverp->addr.sin_addr.s_addr,
+ tcp->rxconnp = rx_NewConnection(serverp->addr.sin_addr.s_addr,
port,
serviceID,
secObjp,
secIndex);
- rx_SetConnDeadTime(tcp->callp, ConnDeadtimeout);
- rx_SetConnHardDeadTime(tcp->callp, HardDeadtimeout);
+ rx_SetConnDeadTime(tcp->rxconnp, ConnDeadtimeout);
+ rx_SetConnHardDeadTime(tcp->rxconnp, HardDeadtimeout);
+ rx_SetConnIdleDeadTime(tcp->rxconnp, IdleDeadtimeout);
tcp->ucgen = ucellp->gen;
if (secObjp)
rxs_Release(secObjp); /* Decrement the initial refCount */
userp = cm_rootUserp;
lock_ObtainMutex(&userp->mx);
- lock_ObtainWrite(&cm_connLock);
+ lock_ObtainRead(&cm_connLock);
for (tcp = serverp->connsp; tcp; tcp=tcp->nextp) {
if (tcp->userp == userp)
break;
/* find ucell structure */
ucellp = cm_GetUCell(userp, serverp->cellp);
if (!tcp) {
+ lock_ConvertRToW(&cm_connLock);
+ for (tcp = serverp->connsp; tcp; tcp=tcp->nextp) {
+ if (tcp->userp == userp)
+ break;
+ }
+ if (tcp) {
+ lock_ReleaseWrite(&cm_connLock);
+ goto haveconn;
+ }
cm_GetServer(serverp);
tcp = malloc(sizeof(*tcp));
memset(tcp, 0, sizeof(*tcp));
serverp->connsp = tcp;
cm_HoldUser(userp);
tcp->userp = userp;
- lock_InitializeMutex(&tcp->mx, "cm_conn_t mutex");
+ lock_InitializeMutex(&tcp->mx, "cm_conn_t mutex", LOCK_HIERARCHY_CONN);
lock_ObtainMutex(&tcp->mx);
tcp->serverp = serverp;
tcp->cryptlevel = rxkad_clear;
cm_NewRXConnection(tcp, ucellp, serverp);
tcp->refCount = 1;
lock_ReleaseMutex(&tcp->mx);
+ lock_ReleaseWrite(&cm_connLock);
} else {
+ lock_ReleaseRead(&cm_connLock);
+ haveconn:
+ InterlockedIncrement(&tcp->refCount);
+
+ lock_ObtainMutex(&tcp->mx);
if ((tcp->flags & CM_CONN_FLAG_FORCE_NEW) ||
(tcp->ucgen < ucellp->gen) ||
- (tcp->cryptlevel != (cryptall ? (ucellp->flags & CM_UCELLFLAG_RXKAD ? rxkad_crypt : rxkad_clear) : rxkad_clear)))
+ (tcp->cryptlevel != (ucellp->flags & CM_UCELLFLAG_RXKAD ? (cryptall == 1 ? rxkad_crypt : (cryptall == 2 ? rxkad_auth : rxkad_clear)) : rxkad_clear)))
{
if (tcp->ucgen < ucellp->gen)
osi_Log0(afsd_logp, "cm_ConnByServer replace connection due to token update");
else
osi_Log0(afsd_logp, "cm_ConnByServer replace connection due to crypt change");
- lock_ObtainMutex(&tcp->mx);
tcp->flags &= ~CM_CONN_FLAG_FORCE_NEW;
- rx_DestroyConnection(tcp->callp);
+ rx_DestroyConnection(tcp->rxconnp);
cm_NewRXConnection(tcp, ucellp, serverp);
- lock_ReleaseMutex(&tcp->mx);
}
- tcp->refCount++;
+ lock_ReleaseMutex(&tcp->mx);
}
- lock_ReleaseWrite(&cm_connLock);
lock_ReleaseMutex(&userp->mx);
/* return this pointer to our caller */
if (code)
return 0;
- lock_ObtainWrite(&cm_serverLock);
+ lock_ObtainRead(&cm_serverLock);
for (tsrp = *serverspp; tsrp; tsrp=tsrp->next) {
tsp = tsrp->server;
- cm_GetServerNoLock(tsp);
if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
allDown = 0;
if (tsrp->status == srv_busy) {
allBusy = 0;
}
}
- cm_PutServerNoLock(tsp);
}
- lock_ReleaseWrite(&cm_serverLock);
+ lock_ReleaseRead(&cm_serverLock);
cm_FreeServerList(serverspp, 0);
if (allDown)
extern struct rx_connection *
cm_GetRxConn(cm_conn_t *connp)
{
- struct rx_connection * rxconn;
+ struct rx_connection * rxconnp;
lock_ObtainMutex(&connp->mx);
- rxconn = connp->callp;
- rx_GetConnection(rxconn);
+ rxconnp = connp->rxconnp;
+ rx_GetConnection(rxconnp);
lock_ReleaseMutex(&connp->mx);
- return rxconn;
+ return rxconnp;
}
void cm_ForceNewConnections(cm_server_t *serverp)
git://git.openafs.org / openafs.git / blobdiff