}
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));
}
/*!
for (safety3 = 0; safety3 < AFS_MAXHOSTS * 2; safety3++) {
tc = afs_ConnByHost(tsp, tsp->cell->fsport,
tsp->cell->cellNum, &treq, 0,
- SHARED_LOCK, &rxconn);
+ SHARED_LOCK, 0, &rxconn);
if (tc) {
XSTATS_START_TIME
(AFS_STATS_FS_RPCIDX_GIVEUPCALLBACKS);
nvc = tvc->hnext;
if (afs_FlushVCache(tvc, &slept)) {
- afs_warn("Failed to flush vcache 0x%lx\n", (unsigned long)(uintptr_t)tvc);
+ afs_warn("Failed to flush vcache 0x%lx\n", (unsigned long)(uintptrsz)tvc);
}
if (slept) {
goto retry;
struct AFSFetchStatus *astat, struct vrequest *areq)
{
afs_size_t length;
+#ifdef AFS_DARWIN80_ENV
+ int fixup = 0;
+#endif
AFS_STATCNT(afs_ProcessFS);
#ifdef AFS_64BIT_CLIENT
avc->f.m.Group = astat->Group;
avc->f.m.LinkCount = astat->LinkCount;
if (astat->FileType == File) {
+#ifdef AFS_DARWIN80_ENV
+ if (avc->f.m.Type != VREG)
+ fixup = 1;
+#endif
vSetType(avc, VREG);
avc->f.m.Mode |= S_IFREG;
} else if (astat->FileType == Directory) {
+#ifdef AFS_DARWIN80_ENV
+ if (avc->f.m.Type != VDIR)
+ fixup = 1;
+#endif
vSetType(avc, VDIR);
avc->f.m.Mode |= S_IFDIR;
} else if (astat->FileType == SymbolicLink) {
if (afs_fakestat_enable && (avc->f.m.Mode & 0111) == 0) {
+#ifdef AFS_DARWIN80_ENV
+ if (avc->f.m.Type != VDIR)
+ fixup = 1;
+#endif
vSetType(avc, VDIR);
avc->f.m.Mode |= S_IFDIR;
} else {
+#ifdef AFS_DARWIN80_ENV
+ if (avc->f.m.Type != VLNK)
+ fixup = 1;
+#endif
vSetType(avc, VLNK);
avc->f.m.Mode |= S_IFLNK;
}
avc->mvstat = 1;
}
}
+#ifdef AFS_DARWIN80_ENV
+ if (fixup)
+ printf("found mistyped vnode!\n");
+#endif
avc->f.anyAccess = astat->AnonymousAccess;
#ifdef badidea
if ((astat->CallerAccess & ~astat->AnonymousAccess))
}
#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);
}
+/**
+ * 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) {
+
+ return VBUSY;
+ }
+ return 0;
+}
+
/*!
* Must be called with avc write-locked
* don't absolutely have to invalidate the hint unless the dv has
XSTATS_END_TIME;
+ if (code == 0) {
+ code = afs_CheckFetchStatus(tc, Outsp);
+ }
+
} else
code = -1;
} while (afs_Analyze
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) {
git://git.openafs.org / openafs.git / blobdiff