/* read/write lock for all global storage in this module */
osi_rwlock_t cm_callbackLock;
+afs_int32 cm_OfflineROIsValid = 0;
+
+afs_int32 cm_giveUpAllCBs = 0;
+
#ifdef AFS_FREELANCE_CLIENT
extern osi_mutex_t cm_Freelance_Lock;
#endif
*/
void cm_RevokeVolumeCallback(struct rx_call *callp, cm_cell_t *cellp, AFSFid *fidp)
{
- long hash;
+ unsigned long hash;
cm_scache_t *scp;
cm_fid_t tfid;
cm_CallbackNotifyChange(scp);
lock_ObtainWrite(&cm_scacheLock);
cm_ReleaseSCacheNoLock(scp);
+
+ if (scp->flags & CM_SCACHEFLAG_PURERO && scp->volp) {
+ scp->volp->cbExpiresRO = 0;
+ }
+
}
} /* search one hash bucket */
} /* search all hash buckets */
unsigned long host = 0;
unsigned short port = 0;
cm_server_t *tsp = NULL;
- cm_cell_t * cellp = NULL;
MUTEX_ENTER(&callp->lock);
host = rx_HostOf(peerp);
port = rx_PortOf(peerp);
- tsp = cm_FindServerByIP(host, CM_SERVER_FILE);
- if (tsp)
- cellp = tsp->cellp;
+ osi_Log2(afsd_logp, "SRXAFSCB_CallBack from host 0x%x port %d",
+ ntohl(host),
+ ntohs(port));
+ } else {
+ osi_Log0(afsd_logp, "SRXAFSCB_CallBack from unknown host");
}
- osi_Log2(afsd_logp, "SRXAFSCB_CallBack from host 0x%x port %d",
- ntohl(host),
- ntohs(port));
for (i=0; i < (long) fidsArrayp->AFSCBFids_len; i++) {
tfidp = &fidsArrayp->AFSCBFids_val[i];
if (tfidp->Volume == 0)
continue; /* means don't do anything */
else if (tfidp->Vnode == 0)
- cm_RevokeVolumeCallback(callp, cellp, tfidp);
+ cm_RevokeVolumeCallback(callp, NULL, tfidp);
else
- cm_RevokeCallback(callp, cellp, tfidp);
+ cm_RevokeCallback(callp, NULL, tfidp);
}
MUTEX_EXIT(&callp->lock);
struct sockaddr_in taddr;
cm_server_t *tsp;
cm_scache_t *scp;
- int hash;
+ afs_uint32 hash;
int discarded;
struct rx_connection *connp;
struct rx_peer *peerp;
cm_CallbackNotifyChange(scp);
lock_ObtainWrite(&cm_scacheLock);
cm_ReleaseSCacheNoLock(scp);
+
+ if (discarded && (scp->flags & CM_SCACHEFLAG_PURERO) && scp->volp && scp->volp->cbExpiresRO != 0)
+ scp->volp->cbExpiresRO = 0;
+
} /* search one hash bucket */
} /* search all hash buckets */
int
SRXAFSCB_GetCE(struct rx_call *callp, long index, AFSDBCacheEntry *cep)
{
- int i;
+ afs_uint32 i;
cm_scache_t * scp;
int code;
struct rx_connection *connp;
cep->lock.pid_writer = 0;
cep->lock.src_indicator = 0;
cep->Length = scp->length.LowPart;
- cep->DataVersion = scp->dataVersion;
+ cep->DataVersion = (afs_uint32)(scp->dataVersion & 0xFFFFFFFF);
cep->callback = afs_data_pointer_to_int32(scp->cbServerp);
- cep->cbExpires = scp->cbExpires;
+ if (scp->flags & CM_SCACHEFLAG_PURERO && scp->volp)
+ cep->cbExpires = scp->volp->cbExpiresRO;
+ else
+ cep->cbExpires = scp->cbExpires;
cep->refCount = scp->refCount;
cep->opens = scp->openReads;
cep->writers = scp->openWrites;
int
SRXAFSCB_GetCE64(struct rx_call *callp, long index, AFSDBCacheEntry64 *cep)
{
- int i;
+ afs_uint32 i;
cm_scache_t * scp;
int code;
struct rx_connection *connp;
#else
cep->Length = (afs_int64) scp->length.QuadPart;
#endif
- cep->DataVersion = scp->dataVersion;
+ cep->DataVersion = (afs_uint32)(scp->dataVersion & 0xFFFFFFFF);
cep->callback = afs_data_pointer_to_int32(scp->cbServerp);
- cep->cbExpires = scp->cbExpires;
+ if (scp->flags & CM_SCACHEFLAG_PURERO && scp->volp)
+ cep->cbExpires = scp->volp->cbExpiresRO;
+ else
+ cep->cbExpires = scp->cbExpires;
cep->refCount = scp->refCount;
cep->opens = scp->openReads;
cep->writers = scp->openWrites;
#ifndef SIZE_MAX
#define SIZE_MAX UINT_MAX
#endif
- osi_assert(allocsize < SIZE_MAX);
+ osi_assertx(allocsize < SIZE_MAX, "allocsize >= SIZE_MAX");
#endif
*configCount = (afs_uint32)allocsize;
config->cacheConfig_val = t_config;
}
#endif
- if (scp->cbServerp != NULL)
+ if (scp->cbServerp != NULL) {
return 1;
- else
+ } else if (cm_OfflineROIsValid) {
+ switch (cm_GetVolumeStatus(scp->volp, scp->fid.volume)) {
+ case vl_offline:
+ case vl_alldown:
+ case vl_unknown:
+ return 1;
+ default:
+ return 0;
+ }
+ } else {
return 0;
+ }
}
/* need to detect a broken callback that races with our obtaining a callback.
lock_ObtainWrite(&cm_callbackLock);
cbrp->callbackCount = cm_callbackCount;
cm_activeCallbackGrantingCalls++;
- cbrp->startTime = osi_Time();
+ cbrp->startTime = time(NULL);
cbrp->serverp = NULL;
lock_ReleaseWrite(&cm_callbackLock);
}
cm_racingRevokes_t *nrevp; /* where we'll be next */
int freeFlag;
cm_server_t * serverp = NULL;
- int discardScp = 0;
+ int discardScp = 0, discardVolCB = 0;
lock_ObtainWrite(&cm_callbackLock);
if (flags & CM_CALLBACK_MAINTAINCOUNT) {
- osi_assert(cm_activeCallbackGrantingCalls > 0);
+ osi_assertx(cm_activeCallbackGrantingCalls > 0,
+ "CM_CALLBACK_MAINTAINCOUNT && cm_activeCallbackGrantingCalls == 0");
}
else {
- osi_assert(cm_activeCallbackGrantingCalls-- > 0);
+ osi_assertx(cm_activeCallbackGrantingCalls-- > 0,
+ "!CM_CALLBACK_MAINTAINCOUNT && cm_activeCallbackGrantingCalls == 0");
}
if (cm_activeCallbackGrantingCalls == 0)
freeFlag = 1;
serverp = cbrp->serverp;
}
scp->cbExpires = cbrp->startTime + cbp->ExpirationTime;
+ if (scp->flags & CM_SCACHEFLAG_PURERO && scp->volp)
+ scp->volp->cbExpiresRO = scp->cbExpires;
} else {
if (freeFlag)
serverp = cbrp->serverp;
cbrp->callbackCount, revp->callbackCount,
cm_callbackCount);
discardScp = 1;
+
+ if ((scp->flags & CM_SCACHEFLAG_PURERO) && scp->volp &&
+ (revp->flags & (CM_RACINGFLAG_CANCELVOL | CM_RACINGFLAG_CANCELALL)))
+ scp->volp->cbExpiresRO = 0;
}
if (freeFlag)
free(revp);
/* called periodically by cm_daemon to shut down use of expired callbacks */
void cm_CheckCBExpiration(void)
{
- int i;
+ afs_uint32 i;
cm_scache_t *scp;
- time_t now, downTime = 0;
+ time_t now, downTime;
osi_Log0(afsd_logp, "CheckCBExpiration");
- now = osi_Time();
+ now = time(NULL);
lock_ObtainWrite(&cm_scacheLock);
for (i=0; i<cm_data.scacheHashTableSize; i++) {
for (scp = cm_data.scacheHashTablep[i]; scp; scp=scp->nextp) {
+ downTime = 0;
+ if (scp->flags & CM_SCACHEFLAG_PURERO && scp->volp) {
+ if (scp->volp->cbExpiresRO > scp->cbExpires && scp->cbExpires > 0)
+ scp->cbExpires = scp->volp->cbExpiresRO;
+ }
if (scp->cbServerp && scp->cbExpires > 0 && now > scp->cbExpires &&
(cm_CBServersUp(scp, &downTime) || downTime == 0 || downTime >= scp->cbExpires))
void
-cm_GiveUpAllCallbacks(cm_server_t *tsp)
+cm_GiveUpAllCallbacks(cm_server_t *tsp, afs_int32 markDown)
{
long code;
cm_conn_t *connp;
struct rx_connection * rxconnp;
- if (tsp->type == CM_SERVER_FILE && !(tsp->flags & CM_SERVERFLAG_DOWN)) {
+ if ((tsp->type == CM_SERVER_FILE) && !(tsp->flags & CM_SERVERFLAG_DOWN))
+ {
code = cm_ConnByServer(tsp, cm_rootUserp, &connp);
if (code == 0) {
rxconnp = cm_GetRxConn(connp);
rx_SetConnDeadTime(rxconnp, 10);
- code = RXAFS_GiveUpAllCallBacks(rxconnp);
+ code = RXAFS_GiveUpAllCallBacks(rxconnp);
rx_SetConnDeadTime(rxconnp, ConnDeadtimeout);
- rx_PutConnection(rxconnp);
+ rx_PutConnection(rxconnp);
+ }
+
+ if (markDown) {
+ cm_server_vols_t * tsrvp;
+ cm_volume_t * volp;
+ int i;
+
+ lock_ObtainMutex(&tsp->mx);
+ if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
+ tsp->flags |= CM_SERVERFLAG_DOWN;
+ tsp->downTime = osi_Time();
+ }
+ cm_ForceNewConnections(tsp);
+ /* Now update the volume status */
+ for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
+ for (i=0; i<NUM_SERVER_VOLS; i++) {
+ if (tsrvp->ids[i] != 0) {
+ cm_req_t req;
+
+ cm_InitReq(&req);
+
+ code = cm_GetVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
+ &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
+ if (code == 0) {
+ cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
+ cm_PutVolume(volp);
+ }
+ }
+ }
+ }
+ lock_ReleaseMutex(&tsp->mx);
}
}
}
void
-cm_GiveUpAllCallbacksAllServers(void)
+cm_GiveUpAllCallbacksAllServers(afs_int32 markDown)
{
cm_server_t *tsp;
+ if (!cm_giveUpAllCBs)
+ return;
+
lock_ObtainWrite(&cm_serverLock);
for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
cm_GetServerNoLock(tsp);
lock_ReleaseWrite(&cm_serverLock);
- cm_GiveUpAllCallbacks(tsp);
+ cm_GiveUpAllCallbacks(tsp, markDown);
lock_ObtainWrite(&cm_serverLock);
cm_PutServerNoLock(tsp);
}
git://git.openafs.org / openafs.git / blobdiff