for (wvc = *uvc; wvc; uvc = &wvc->hnext, wvc = *uvc) {
if (avc == wvc) {
*uvc = avc->hnext;
- avc->hnext = (struct vcache *)NULL;
+ avc->hnext = NULL;
break;
}
}
vn_reinit(AFSTOV(avc));
#endif
afs_FreeAllAxs(&(avc->Access));
- if (!afs_shuttingdown)
- afs_QueueVCB(avc, slept);
ObtainWriteLock(&afs_xcbhash, 460);
afs_DequeueCallback(avc); /* remove it from queued callbacks list */
avc->f.states &= ~(CStatd | CUnique);
else
osi_dnlc_purgevp(avc);
+ if (!afs_shuttingdown)
+ afs_QueueVCB(avc, slept);
+
/*
* Next, keep track of which vnodes we've deleted for create's
* optimistic synchronization algorithm
}
static void
-FlushAllVCBs(struct rx_connection **rxconns, int nconns, int nservers,
- struct afs_conn **conns, struct srvAddr **addrs)
+FlushAllVCBs(int nconns, struct rx_connection **rxconns,
+ struct afs_conn **conns)
{
afs_int32 *results;
afs_int32 i;
- results = afs_osi_Alloc(nservers * sizeof (afs_int32));
+ results = afs_osi_Alloc(nconns * sizeof (afs_int32));
osi_Assert(results != NULL);
AFS_GUNLOCK();
for ( i = 0 ; i < nconns ; i++ ) {
if (results[i] == 0) {
/* Unchain all of them */
- while (addrs[i]->server->cbrs)
- afs_FreeCBR(addrs[i]->server->cbrs);
+ while (conns[i]->parent->srvr->server->cbrs)
+ afs_FreeCBR(conns[i]->parent->srvr->server->cbrs);
}
}
- afs_osi_Free(results, nservers * sizeof(afs_int32));
+ afs_osi_Free(results, nconns * sizeof(afs_int32));
}
/*!
tcount = 0; /* number found so far */
for (safety2 = 0; safety2 < afs_cacheStats; safety2++) {
if (tcount >= AFS_MAXCBRSCALL || !tsp->cbrs) {
+ struct rx_connection *rxconn;
/* if buffer is full, or we've queued all we're going
* to from this server, we should flush out the
* callbacks.
for (safety3 = 0; safety3 < AFS_MAXHOSTS * 2; safety3++) {
tc = afs_ConnByHost(tsp, tsp->cell->fsport,
tsp->cell->cellNum, &treq, 0,
- SHARED_LOCK);
+ SHARED_LOCK, 0, &rxconn);
if (tc) {
XSTATS_START_TIME
(AFS_STATS_FS_RPCIDX_GIVEUPCALLBACKS);
RX_AFS_GUNLOCK();
code =
- RXAFS_GiveUpCallBacks(tc->id, &fidArray,
+ RXAFS_GiveUpCallBacks(rxconn, &fidArray,
&cbArray);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
if (!afs_Analyze
- (tc, code, 0, &treq,
+ (tc, rxconn, code, 0, &treq,
AFS_STATS_FS_RPCIDX_GIVEUPCALLBACKS, SHARED_LOCK,
tsp->cell)) {
break;
i = 0;
continue; /* start over - may have raced. */
}
- if (tq == uq) {
+ if (uq == &VLRU) {
if (anumber && !defersleep) {
defersleep = 1;
- tq = VLRU.prev;
+ uq = VLRU.prev;
+ i = 0;
continue;
}
break;
#endif
}
+void
+afs_FlushAllVCaches(void)
+{
+ int i;
+ struct vcache *tvc, *nvc;
+
+ ObtainWriteLock(&afs_xvcache, 867);
+
+ retry:
+ for (i = 0; i < VCSIZE; i++) {
+ for (tvc = afs_vhashT[i]; tvc; tvc = nvc) {
+ int slept;
+
+ nvc = tvc->hnext;
+ if (afs_FlushVCache(tvc, &slept)) {
+ afs_warn("Failed to flush vcache 0x%lx\n", (unsigned long)(uintptrsz)tvc);
+ }
+ if (slept) {
+ goto retry;
+ }
+ }
+ }
+
+ ReleaseWriteLock(&afs_xvcache);
+}
+
/*!
* This routine is responsible for allocating a new cache entry
* from the free list. It formats the cache entry and inserts it
tvc->flockCount)) panic("Dead vnode has core/unlinkedel/flock");
#endif
if (doflocks && tvc->flockCount != 0) {
+ struct rx_connection *rxconn;
/* if this entry has an flock, send a keep-alive call out */
osi_vnhold(tvc, 0);
ReleaseReadLock(&afs_xvcache);
afs_InitReq(&treq, afs_osi_credp);
treq.flags |= O_NONBLOCK;
- tc = afs_Conn(&tvc->f.fid, &treq, SHARED_LOCK);
+ tc = afs_Conn(&tvc->f.fid, &treq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_EXTENDLOCK);
RX_AFS_GUNLOCK();
code =
- RXAFS_ExtendLock(tc->id,
+ RXAFS_ExtendLock(rxconn,
(struct AFSFid *)&tvc->f.fid.Fid,
&tsync);
RX_AFS_GLOCK();
} else
code = -1;
} while (afs_Analyze
- (tc, code, &tvc->f.fid, &treq,
+ (tc, rxconn, code, &tvc->f.fid, &treq,
AFS_STATS_FS_RPCIDX_EXTENDLOCK, SHARED_LOCK, NULL));
ReleaseWriteLock(&tvc->lock);
struct afs_conn *tc;
struct AFSFetchStatus OutStatus;
struct AFSVolSync tsync;
+ struct rx_connection *rxconn;
XSTATS_DECLS;
AFS_STATCNT(afs_WriteVCache);
afs_Trace2(afs_iclSetp, CM_TRACE_WVCACHE, ICL_TYPE_POINTER, avc,
ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length));
do {
- tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
+ tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_STORESTATUS);
RX_AFS_GUNLOCK();
code =
- RXAFS_StoreStatus(tc->id, (struct AFSFid *)&avc->f.fid.Fid,
+ RXAFS_StoreStatus(rxconn, (struct AFSFid *)&avc->f.fid.Fid,
astatus, &OutStatus, &tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
} while (afs_Analyze
- (tc, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_STORESTATUS,
+ (tc, rxconn, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_STORESTATUS,
SHARED_LOCK, NULL));
UpgradeSToWLock(&avc->lock, 20);
{
afs_int32 code;
struct afs_conn *tc;
+ struct rx_connection *rxconn;
struct AFSFetchStatus OutDirStatus;
XSTATS_DECLS;
if (!name)
name = ""; /* XXX */
do {
- tc = afs_Conn(afid, areq, SHARED_LOCK);
+ tc = afs_Conn(afid, areq, SHARED_LOCK, &rxconn);
if (tc) {
if (serverp)
*serverp = tc->parent->srvr->server;
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_XLOOKUP);
RX_AFS_GUNLOCK();
code =
- RXAFS_Lookup(tc->id, (struct AFSFid *)&afid->Fid, name,
+ RXAFS_Lookup(rxconn, (struct AFSFid *)&afid->Fid, name,
(struct AFSFid *)&nfid->Fid, OutStatusp,
&OutDirStatus, CallBackp, tsyncp);
RX_AFS_GLOCK();
} else
code = -1;
} while (afs_Analyze
- (tc, code, afid, areq, AFS_STATS_FS_RPCIDX_XLOOKUP, SHARED_LOCK,
+ (tc, rxconn, code, afid, areq, AFS_STATS_FS_RPCIDX_XLOOKUP, SHARED_LOCK,
NULL));
return code;
}
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
- if (!(tvc->f.states & CBulkFetching)) {
- ReleaseSharedLock(&afs_xvcache);
- afs_osi_Sleep(&tvc->f.states);
- goto rootvc_loop;
- }
+ ReleaseSharedLock(&afs_xvcache);
+ afs_osi_Sleep(&tvc->f.states);
+ goto rootvc_loop;
}
tvp = AFSTOV(tvc);
if (vnode_get(tvp)) /* this bumps ref count */
AFS_GLOCK();
continue;
}
- if (tvc->f.states & (CBulkFetching|CDeadVnode)) {
- AFS_GUNLOCK();
- vnode_recycle(AFSTOV(tvc));
- AFS_GLOCK();
- }
#endif
break;
}
afs_PutVolume(volp, READ_LOCK);
}
+void
+afs_BadFetchStatus(struct afs_conn *tc)
+{
+ int addr = ntohl(tc->parent->srvr->sa_ip);
+ afs_warn("afs: Invalid AFSFetchStatus from server %u.%u.%u.%u\n",
+ (addr >> 24) & 0xff, (addr >> 16) & 0xff, (addr >> 8) & 0xff,
+ (addr) & 0xff);
+ afs_warn("afs: This suggests the server may be sending bad data that "
+ "can lead to availability issues or data corruption. The "
+ "issue has been avoided for now, but it may not always be "
+ "detectable. Please upgrade the server if possible.\n");
+}
+
+/**
+ * Check if a given AFSFetchStatus structure is sane.
+ *
+ * @param[in] tc The server from which we received the status
+ * @param[in] status The status we received
+ *
+ * @return whether the given structure is valid or not
+ * @retval 0 the structure is fine
+ * @retval nonzero the structure looks like garbage; act as if we received
+ * the returned error code from the server
+ */
+int
+afs_CheckFetchStatus(struct afs_conn *tc, struct AFSFetchStatus *status)
+{
+ if (status->errorCode ||
+ status->InterfaceVersion != 1 ||
+ !(status->FileType > Invalid && status->FileType <= SymbolicLink) ||
+ status->ParentVnode == 0 || status->ParentUnique == 0) {
+
+ afs_warn("afs: FetchStatus ec %u iv %u ft %u pv %u pu %u\n",
+ (unsigned)status->errorCode, (unsigned)status->InterfaceVersion,
+ (unsigned)status->FileType, (unsigned)status->ParentVnode,
+ (unsigned)status->ParentUnique);
+ afs_BadFetchStatus(tc);
+
+ return VBUSY;
+ }
+ return 0;
+}
+
/*!
* Must be called with avc write-locked
* don't absolutely have to invalidate the hint unless the dv has
struct afs_conn *tc;
struct AFSCallBack CallBack;
struct AFSVolSync tsync;
+ struct rx_connection *rxconn;
XSTATS_DECLS;
do {
- tc = afs_Conn(afid, areq, SHARED_LOCK);
+ tc = afs_Conn(afid, areq, SHARED_LOCK, &rxconn);
avc->dchint = NULL; /* invalidate hints */
if (tc) {
avc->callback = tc->parent->srvr->server;
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_FETCHSTATUS);
RX_AFS_GUNLOCK();
code =
- RXAFS_FetchStatus(tc->id, (struct AFSFid *)&afid->Fid, Outsp,
+ RXAFS_FetchStatus(rxconn, (struct AFSFid *)&afid->Fid, Outsp,
&CallBack, &tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
+ if (code == 0) {
+ code = afs_CheckFetchStatus(tc, Outsp);
+ }
+
} else
code = -1;
} while (afs_Analyze
- (tc, code, afid, areq, AFS_STATS_FS_RPCIDX_FETCHSTATUS,
+ (tc, rxconn, code, afid, areq, AFS_STATS_FS_RPCIDX_FETCHSTATUS,
SHARED_LOCK, NULL));
if (!code) {
*
* \param avc Pointer to the cache entry to reset
* \param acred
+ * \param skipdnlc skip the dnlc purge for this vnode
*
* \note avc must be write locked on entry
+ *
+ * \note The caller should purge the dnlc when skipdnlc is set.
*/
void
-afs_ResetVCache(struct vcache *avc, afs_ucred_t *acred)
+afs_ResetVCache(struct vcache *avc, afs_ucred_t *acred, afs_int32 skipdnlc)
{
ObtainWriteLock(&afs_xcbhash, 456);
afs_DequeueCallback(avc);
ReleaseWriteLock(&afs_xcbhash);
/* now find the disk cache entries */
afs_TryToSmush(avc, acred, 1);
- osi_dnlc_purgedp(avc);
+ if (!skipdnlc) {
+ osi_dnlc_purgedp(avc);
+ }
if (avc->linkData && !(avc->f.states & CCore)) {
afs_osi_Free(avc->linkData, strlen(avc->linkData) + 1);
avc->linkData = NULL;
static void
findvc_sleep(struct vcache *avc, int flag)
{
- int fstates = avc->f.states;
if (flag & IS_SLOCK) {
ReleaseSharedLock(&afs_xvcache);
} else {
ReleaseReadLock(&afs_xvcache);
}
}
- if (flag & FIND_CDEAD) {
- ObtainWriteLock(&afs_xvcache, 342);
- afs_FlushReclaimedVcaches();
- if (fstates == avc->f.states) {
- ReleaseWriteLock(&afs_xvcache);
- afs_osi_Sleep(&avc->f.states);
- } else
- ReleaseWriteLock(&afs_xvcache);
- } else
- afs_osi_Sleep(&avc->f.states);
+ afs_osi_Sleep(&avc->f.states);
if (flag & IS_SLOCK) {
ObtainSharedLock(&afs_xvcache, 341);
} else {
i = VCHash(afid);
for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
if (FidMatches(afid, tvc)) {
-#ifdef AFS_DARWIN80_ENV
- if (flag & FIND_CDEAD) {
- if (tvc->f.states & (CDeadVnode|CBulkFetching)) {
- deadvc = tvc;
- continue;
- }
- } else {
- if (tvc->f.states & CDeadVnode)
- if ((tvc->f.states & CBulkFetching) &&
- !(flag & FIND_BULKDEAD))
- continue;
- }
-#endif
if (tvc->f.states & CVInit) {
findvc_sleep(tvc, flag);
goto findloop;
findvc_sleep(tvc, flag);
goto findloop;
}
- if (flag & FIND_CDEAD) {
- livevc = tvc;
- continue;
- }
#endif
break;
}
}
-#ifdef AFS_DARWIN80_ENV
- if (flag & FIND_CDEAD) {
- if (livevc && deadvc) {
- /* discard deadvc */
- AFS_GUNLOCK();
- vnode_recycle(AFSTOV(deadvc));
- vnode_put(AFSTOV(deadvc));
- vnode_rele(AFSTOV(deadvc));
- AFS_GLOCK();
- deadvc = NULL;
- }
-
- /* return what's left */
- tvc = livevc ? livevc : deadvc;
- }
-#endif
/* should I have a read lock on the vnode here? */
if (tvc) {
AFS_GLOCK();
tvp = NULL;
}
- if (tvp && (tvc->f.states & (CBulkFetching|CDeadVnode))) {
- AFS_GUNLOCK();
- vnode_recycle(AFSTOV(tvc));
- AFS_GLOCK();
- }
if (!tvp) {
tvc = NULL;
return tvc;
}
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
- if (!(tvc->f.states & CBulkFetching)) {
- ReleaseSharedLock(&afs_xvcache);
- afs_osi_Sleep(&tvc->f.states);
- goto loop;
- }
+ ReleaseSharedLock(&afs_xvcache);
+ afs_osi_Sleep(&tvc->f.states);
+ goto loop;
}
tvp = AFSTOV(tvc);
if (vnode_get(tvp)) {
AFS_GLOCK();
continue;
}
- if (tvc->f.states & (CBulkFetching|CDeadVnode)) {
- AFS_GUNLOCK();
- vnode_recycle(AFSTOV(tvc));
- AFS_GLOCK();
- }
#endif /* AFS_DARWIN80_ENV */
count++;
if (found_tvc) {