}
long cm_GetVolServerList(cm_volume_t *volp, afs_uint32 volid, struct cm_user *userp,
- struct cm_req *reqp, afs_uint32 *replicated, cm_serverRef_t ***serversppp)
+ struct cm_req *reqp, afs_uint32 *replicated,
+ cm_serverRef_t ***serversppp)
{
*serversppp = cm_GetVolServers(volp, volid, userp, reqp, replicated);
return (*serversppp ? 0 : CM_ERROR_NOSUCHVOLUME);
return (*serversppp ? 0 : CM_ERROR_NOSUCHVOLUME);
}
-void
-cm_SetServerBusyStatus(cm_serverRef_t *serversp, cm_server_t *serverp)
+static void
+cm_SetServerBusyStatus(cm_serverRef_t **serverspp, cm_server_t *serverp)
{
cm_serverRef_t *tsrp;
- lock_ObtainWrite(&cm_serverLock);
- for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
+ lock_ObtainRead(&cm_serverLock);
+ for (tsrp = *serverspp; tsrp; tsrp=tsrp->next) {
if (tsrp->status == srv_deleted)
continue;
if (cm_ServerEqual(tsrp->server, serverp) && tsrp->status == srv_not_busy) {
break;
}
}
- lock_ReleaseWrite(&cm_serverLock);
+ lock_ReleaseRead(&cm_serverLock);
}
-void
-cm_ResetServerBusyStatus(cm_serverRef_t *serversp)
+static void
+cm_ResetServerBusyStatus(cm_serverRef_t **serverspp)
{
cm_serverRef_t *tsrp;
- lock_ObtainWrite(&cm_serverLock);
- for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
+ lock_ObtainRead(&cm_serverLock);
+ for (tsrp = *serverspp; tsrp; tsrp=tsrp->next) {
if (tsrp->status == srv_deleted)
continue;
if (tsrp->status == srv_busy) {
tsrp->status = srv_not_busy;
}
}
- lock_ReleaseWrite(&cm_serverLock);
+ lock_ReleaseRead(&cm_serverLock);
}
/*
afs_uint32 storeOp,
AFSFetchStatus *statusp,
AFSVolSync *volSyncp,
- cm_serverRef_t * serversp,
+ cm_serverRef_t ** vlServerspp,
cm_callbackRequest_t *cbrp,
long errorCode)
{
cm_server_t *serverp = NULL;
- cm_serverRef_t **serverspp = NULL;
+ cm_serverRef_t **volServerspp = NULL;
cm_serverRef_t *tsrp;
cm_ucell_t *ucellp;
cm_volume_t * volp = NULL;
if (errorCode) {
if (cellp == NULL && serverp)
cellp = serverp->cellp;
- if (cellp == NULL && serversp) {
+ if (cellp == NULL && vlServerspp) {
struct cm_serverRef * refp;
- for ( refp=serversp ; cellp == NULL && refp != NULL; refp=refp->next) {
+ lock_ObtainRead(&cm_serverLock);
+ for ( refp=*vlServerspp ; cellp == NULL && refp != NULL; refp=refp->next) {
if (refp->status == srv_deleted)
continue;
if ( refp->server )
cellp = refp->server->cellp;
}
+ lock_ReleaseRead(&cm_serverLock);
}
if (cellp == NULL && fidp) {
cellp = cm_FindCellByID(fidp->cell, 0);
}
}
- if (errorCode == CM_ERROR_TIMEDOUT) {
+ if (errorCode == 0) {
+ if (connp)
+ _InterlockedAnd(&connp->flags, ~CM_CONN_FLAG_NEW);
+ }
+ else if (errorCode == CM_ERROR_TIMEDOUT) {
osi_Log0(afsd_logp, "cm_Analyze passed CM_ERROR_TIMEDOUT");
if ( timeLeft > 5 ) {
thrd_Sleep(3000);
thrd_Sleep(1000);
retry = 1;
}
+
+ if (connp)
+ _InterlockedAnd(&connp->flags, ~CM_CONN_FLAG_NEW);
}
/* if there is nosuchvolume, then we have a situation in which a
lock_ObtainWrite(&volp->rw);
if (cm_UpdateVolumeLocation(cellp, userp, reqp, volp) == 0) {
lock_ReleaseWrite(&volp->rw);
- code = cm_GetVolServerList(volp, fidp->volume, userp, reqp, &replicated, &serverspp);
+ code = cm_GetVolServerList(volp, fidp->volume, userp, reqp, &replicated, &volServerspp);
if (code == 0) {
- if (!cm_IsServerListEmpty(*serverspp))
+ if (!cm_IsServerListEmpty(*volServerspp))
retry = 1;
- cm_FreeServerList(serverspp, 0);
+ cm_FreeServerList(volServerspp, 0);
}
} else {
lock_ReleaseWrite(&volp->rw);
CM_GETVOL_FLAG_NO_LRU_UPDATE,
&volp);
if (code == 0) {
- if (!serversp) {
- code = cm_GetVolServerList(volp, fidp->volume, userp, reqp, &replicated, &serverspp);
- if (code == 0) {
- serversp = *serverspp;
+ if (volServerspp == NULL) {
+ code = cm_GetVolServerList(volp, fidp->volume, userp, reqp, &replicated, &volServerspp);
+ if (code == 0)
free_svr_list = 1;
- }
}
- cm_ResetServerBusyStatus(serversp);
+ cm_ResetServerBusyStatus(volServerspp);
if (free_svr_list) {
- cm_FreeServerList(serverspp, 0);
+ cm_FreeServerList(volServerspp, 0);
free_svr_list = 0;
- serversp = NULL;
+ volServerspp = NULL;
}
/*
CM_GETVOL_FLAG_NO_LRU_UPDATE,
&volp);
if (code == 0) {
- if (!serversp) {
- code = cm_GetVolServerList(volp, fidp->volume, userp, reqp, &replicated, &serverspp);
- if (code == 0) {
- serversp = *serverspp;
+ if (volServerspp == NULL) {
+ code = cm_GetVolServerList(volp, fidp->volume, userp, reqp, &replicated, &volServerspp);
+ if (code == 0)
free_svr_list = 1;
- }
}
- cm_ResetServerBusyStatus(serversp);
+ cm_ResetServerBusyStatus(volServerspp);
if (free_svr_list) {
- cm_FreeServerList(serverspp, 0);
+ cm_FreeServerList(volServerspp, 0);
free_svr_list = 0;
- serversp = NULL;
+ volServerspp = NULL;
}
if (timeLeft > 7) {
if (timeLeft > 7) {
thrd_Sleep(5000);
- if (serversp) {
- cm_ResetServerBusyStatus(serversp);
+ if (vlServerspp) {
+ cm_ResetServerBusyStatus(vlServerspp);
retry = 1;
}
}
/* special codes: VBUSY and VRESTARTING */
else if (errorCode == VBUSY || errorCode == VRESTARTING) {
+ if (connp)
+ _InterlockedAnd(&connp->flags, ~CM_CONN_FLAG_NEW);
+
if (fidp) {
code = cm_FindVolumeByID(cellp, fidp->volume, userp, reqp,
CM_GETVOL_FLAG_NO_LRU_UPDATE,
&volp);
if (code == 0) {
- if (!serversp) {
- code = cm_GetVolServerList(volp, fidp->volume, userp, reqp, &replicated, &serverspp);
- if (code == 0) {
- serversp = *serverspp;
+ if (volServerspp == NULL) {
+ code = cm_GetVolServerList(volp, fidp->volume, userp, reqp, &replicated, &volServerspp);
+ if (code == 0)
free_svr_list = 1;
- }
}
statep = cm_VolumeStateByID(volp, fidp->volume);
osi_Log3(afsd_logp, format, osi_LogSaveString(afsd_logp,addr), fidp->volume, cellp->name);
LogEvent(EVENTLOG_WARNING_TYPE, msgID, addr, fidp->volume, cellp->name);
- cm_SetServerBusyStatus(serversp, serverp);
+ cm_SetServerBusyStatus(volServerspp, serverp);
}
if (free_svr_list) {
- cm_FreeServerList(serverspp, 0);
- serversp = NULL;
+ cm_FreeServerList(volServerspp, 0);
+ volServerspp = NULL;
free_svr_list = 0;
}
retry = 1;
else if (errorCode == VNOVOL || errorCode == VMOVED || errorCode == VOFFLINE ||
errorCode == VSALVAGE || errorCode == VIO)
{
+ if (connp)
+ _InterlockedAnd(&connp->flags, ~CM_CONN_FLAG_NEW);
+
/* In case of timeout */
reqp->volumeError = errorCode;
* Mark server offline for this volume or delete the volume
* from the server list if it was moved or is not present.
*/
- if (!serversp || location_updated) {
- code = cm_GetServerList(fidp, userp, reqp, &replicated, &serverspp);
- if (code == 0) {
- serversp = *serverspp;
+ if (volServerspp == NULL || location_updated) {
+ code = cm_GetServerList(fidp, userp, reqp, &replicated, &volServerspp);
+ if (code == 0)
free_svr_list = 1;
- }
}
}
- lock_ObtainWrite(&cm_serverLock);
- for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
- if (tsrp->status == srv_deleted)
- continue;
- sprintf(addr, "%d.%d.%d.%d",
- ((tsrp->server->addr.sin_addr.s_addr & 0xff)),
- ((tsrp->server->addr.sin_addr.s_addr & 0xff00)>> 8),
- ((tsrp->server->addr.sin_addr.s_addr & 0xff0000)>> 16),
- ((tsrp->server->addr.sin_addr.s_addr & 0xff000000)>> 24));
-
- if (cm_ServerEqual(tsrp->server, serverp)) {
- /* REDIRECT */
- switch (errorCode) {
- case VMOVED:
- osi_Log2(afsd_logp, "volume %u moved from server %s",
- fidp->volume, osi_LogSaveString(afsd_logp,addr));
- tsrp->status = srv_deleted;
- if (fidp)
- cm_RemoveVolumeFromServer(serverp, fidp->volume);
- break;
- case VNOVOL:
- /*
- * The 1.6.0 and 1.6.1 file servers send transient VNOVOL errors which
- * are no indicative of the volume not being present. For example,
- * VNOVOL can be sent during a transition to a VBUSY state prior to
- * salvaging or when cloning a .backup volume instance. As a result
- * the cache manager must attempt at least one retry when a VNOVOL is
- * receive but there are no changes to the volume location information.
- */
- if (reqp->vnovolError > 0 && cm_ServerEqual(reqp->errorServp, serverp)) {
- osi_Log2(afsd_logp, "volume %u not present on server %s",
+ if (volServerspp) {
+ lock_ObtainWrite(&cm_serverLock);
+ for (tsrp = *volServerspp; tsrp; tsrp=tsrp->next) {
+ if (tsrp->status == srv_deleted)
+ continue;
+
+ sprintf(addr, "%d.%d.%d.%d",
+ ((tsrp->server->addr.sin_addr.s_addr & 0xff)),
+ ((tsrp->server->addr.sin_addr.s_addr & 0xff00)>> 8),
+ ((tsrp->server->addr.sin_addr.s_addr & 0xff0000)>> 16),
+ ((tsrp->server->addr.sin_addr.s_addr & 0xff000000)>> 24));
+
+ if (cm_ServerEqual(tsrp->server, serverp)) {
+ /* REDIRECT */
+ switch (errorCode) {
+ case VMOVED:
+ osi_Log2(afsd_logp, "volume %u moved from server %s",
fidp->volume, osi_LogSaveString(afsd_logp,addr));
tsrp->status = srv_deleted;
if (fidp)
cm_RemoveVolumeFromServer(serverp, fidp->volume);
- } else {
- osi_Log2(afsd_logp, "VNOVOL received for volume %u from server %s",
- fidp->volume, osi_LogSaveString(afsd_logp,addr));
- if (replicated) {
- if (tsrp->status == srv_not_busy)
- tsrp->status = srv_busy;
+ break;
+ case VNOVOL:
+ /*
+ * The 1.6.0 and 1.6.1 file servers send transient VNOVOL errors which
+ * are no indicative of the volume not being present. For example,
+ * VNOVOL can be sent during a transition to a VBUSY state prior to
+ * salvaging or when cloning a .backup volume instance. As a result
+ * the cache manager must attempt at least one retry when a VNOVOL is
+ * receive but there are no changes to the volume location information.
+ */
+ if (reqp->vnovolError > 0 && cm_ServerEqual(reqp->errorServp, serverp)) {
+ osi_Log2(afsd_logp, "volume %u not present on server %s",
+ fidp->volume, osi_LogSaveString(afsd_logp,addr));
+ tsrp->status = srv_deleted;
+ if (fidp)
+ cm_RemoveVolumeFromServer(serverp, fidp->volume);
} else {
- Sleep(2000);
+ osi_Log2(afsd_logp, "VNOVOL received for volume %u from server %s",
+ fidp->volume, osi_LogSaveString(afsd_logp,addr));
+ if (replicated) {
+ if (tsrp->status == srv_not_busy)
+ tsrp->status = srv_busy;
+ } else {
+ Sleep(2000);
+ }
}
+ break;
+ case VOFFLINE:
+ osi_Log2(afsd_logp, "VOFFLINE received for volume %u from server %s",
+ fidp->volume, osi_LogSaveString(afsd_logp,addr));
+ tsrp->status = srv_offline;
+ break;
+ default:
+ osi_Log3(afsd_logp, "volume %u exists on server %s with status %u",
+ fidp->volume, osi_LogSaveString(afsd_logp,addr), tsrp->status);
}
- break;
- case VOFFLINE:
- osi_Log2(afsd_logp, "VOFFLINE received for volume %u from server %s",
- fidp->volume, osi_LogSaveString(afsd_logp,addr));
- tsrp->status = srv_offline;
- break;
- default:
- osi_Log3(afsd_logp, "volume %u exists on server %s with status %u",
- fidp->volume, osi_LogSaveString(afsd_logp,addr), tsrp->status);
}
}
+ lock_ReleaseWrite(&cm_serverLock);
}
- lock_ReleaseWrite(&cm_serverLock);
/* Remember that the VNOVOL error occurred */
if (errorCode == VNOVOL) {
/* Free the server list before cm_ForceUpdateVolume is called */
if (free_svr_list) {
- cm_FreeServerList(serverspp, 0);
- serversp = NULL;
+ cm_FreeServerList(volServerspp, 0);
+ volServerspp = NULL;
free_svr_list = 0;
}
if ( timeLeft > 2 )
retry = 1;
} else if ( errorCode == VNOVNODE ) {
+ if (connp)
+ _InterlockedAnd(&connp->flags, ~CM_CONN_FLAG_NEW);
+
if ( fidp ) {
osi_Log4(afsd_logp, "cm_Analyze passed VNOVNODE cell %u vol %u vn %u uniq %u.",
fidp->cell, fidp->volume, fidp->vnode, fidp->unique);
* is currently busy on the server. Unconditionally
* retry the request so an alternate call channel can be used.
*/
+ if (connp)
+ _InterlockedAnd(&connp->flags, ~CM_CONN_FLAG_NEW);
+
if (serverp)
sprintf(addr, "%d.%d.%d.%d",
((serverp->addr.sin_addr.s_addr & 0xff)),
* The RPC was not serviced so it can be retried and any
* existing status information is still valid.
*/
+ if (connp)
+ _InterlockedAnd(&connp->flags, ~CM_CONN_FLAG_NEW);
+
if (fidp) {
if (serverp)
sprintf(addr, "%d.%d.%d.%d",
* client should fail over to another server. If this is a
* request against a single source, the client may retry once.
*/
+ if (connp)
+ _InterlockedAnd(&connp->flags, ~CM_CONN_FLAG_NEW);
+
if (serverp)
sprintf(addr, "%d.%d.%d.%d",
((serverp->addr.sin_addr.s_addr & 0xff)),
(reqp->flags & CM_REQ_NEW_CONN_FORCED ? "yes" : "no"));
if (serverp) {
- if ((reqp->flags & CM_REQ_NEW_CONN_FORCED)) {
+ if ((connp->flags & CM_CONN_FLAG_NEW) ||
+ (reqp->flags & CM_REQ_NEW_CONN_FORCED)) {
lock_ObtainMutex(&serverp->mx);
if (!(serverp->flags & CM_SERVERFLAG_DOWN)) {
_InterlockedOr(&serverp->flags, CM_SERVERFLAG_DOWN);
(reqp->flags & CM_REQ_NEW_CONN_FORCED ? "yes" : "no"));
if (serverp) {
- if (reqp->flags & CM_REQ_NEW_CONN_FORCED) {
+ if ((connp->flags & CM_CONN_FLAG_NEW) ||
+ (reqp->flags & CM_REQ_NEW_CONN_FORCED)) {
reqp->errorServp = serverp;
reqp->tokenError = errorCode;
} else {
_InterlockedAnd(&ucellp->flags, ~CM_UCELLFLAG_RXKAD);
ucellp->gen++;
lock_ReleaseMutex(&userp->mx);
+
+ reqp->flags |= CM_REQ_NEW_CONN_FORCED;
+ forcing_new = 1;
+ cm_ForceNewConnections(serverp);
+
if ( timeLeft > 2 )
retry = 1;
}
osi_Log2(afsd_logp, "cm_Analyze: rxkad error code 0x%x (%s)",
errorCode, s);
+ if (connp)
+ _InterlockedAnd(&connp->flags, ~CM_CONN_FLAG_NEW);
+
if (serverp) {
reqp->errorServp = serverp;
reqp->tokenError = errorCode;
* to answer our query. Therefore, we will retry the request
* and force the use of another server.
*/
+ if (connp)
+ _InterlockedAnd(&connp->flags, ~CM_CONN_FLAG_NEW);
+
if (serverp) {
reqp->errorServp = serverp;
reqp->tokenError = errorCode;
retry = 1;
}
} else if (errorCode == VICECONNBAD || errorCode == VICETOKENDEAD) {
- cm_ForceNewConnections(serverp);
+ reqp->flags |= CM_REQ_NEW_CONN_FORCED;
+ forcing_new = 1;
+ cm_ForceNewConnections(serverp);
if ( timeLeft > 2 )
retry = 1;
} else {
+ if (connp)
+ _InterlockedAnd(&connp->flags, ~CM_CONN_FLAG_NEW);
+
if (errorCode) {
char * s = "unknown error";
switch ( errorCode ) {
cm_PutConn(connp);
/*
+
* clear the volume updated flag if we succeed.
* this way the flag will not prevent a subsequent volume
* from being updated if necessary.
reqp->flags &= ~CM_REQ_VOLUME_UPDATED;
}
- if ( serversp &&
+ if ( vlServerspp &&
errorCode != VBUSY &&
errorCode != VRESTARTING &&
errorCode != CM_ERROR_ALLBUSY)
{
- cm_ResetServerBusyStatus(serversp);
+ cm_ResetServerBusyStatus(vlServerspp);
}
/* retry until we fail to find a connection */
* Setting idle dead timeout to a non-zero value activates RX_CALL_IDLE errors
*/
if (replicated) {
- tcp->flags &= CM_CONN_FLAG_REPLICATION;
+ _InterlockedOr(&tcp->flags, CM_CONN_FLAG_REPLICATION);
rx_SetConnIdleDeadTime(tcp->rxconnp, ReplicaIdleDeadtimeout);
} else {
rx_SetConnIdleDeadTime(tcp->rxconnp, IdleDeadtimeout);
tcp->ucgen = ucellp->gen;
if (secObjp)
rxs_Release(secObjp); /* Decrement the initial refCount */
+
+ _InterlockedAnd(&tcp->flags, ~CM_CONN_FLAG_FORCE_NEW);
+ _InterlockedOr(&tcp->flags, CM_CONN_FLAG_NEW);
}
long cm_ConnByServer(cm_server_t *serverp, cm_user_t *userp, afs_uint32 replicated, cm_conn_t **connpp)
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");
- tcp->flags &= ~CM_CONN_FLAG_FORCE_NEW;
rx_SetConnSecondsUntilNatPing(tcp->rxconnp, 0);
rx_DestroyConnection(tcp->rxconnp);
cm_NewRXConnection(tcp, ucellp, serverp, replicated);
lock_ObtainWrite(&cm_connLock);
for (tcp = serverp->connsp; tcp; tcp=tcp->nextp) {
lock_ObtainMutex(&tcp->mx);
- tcp->flags |= CM_CONN_FLAG_FORCE_NEW;
+ _InterlockedOr(&tcp->flags, CM_CONN_FLAG_FORCE_NEW);
lock_ReleaseMutex(&tcp->mx);
}
lock_ReleaseWrite(&cm_connLock);
git://git.openafs.org / openafs.git / blobdiff