vn_reinit(AFSTOV(avc));
#endif
afs_FreeAllAxs(&(avc->Access));
- ObtainWriteLock(&afs_xcbhash, 460);
- afs_DequeueCallback(avc); /* remove it from queued callbacks list */
- avc->f.states &= ~(CStatd | CUnique);
- ReleaseWriteLock(&afs_xcbhash);
- if ((avc->f.states & CForeign) || (avc->f.fid.Fid.Vnode & 1))
- osi_dnlc_purgedp(avc); /* if it (could be) a directory */
- else
- osi_dnlc_purgevp(avc);
+ afs_StaleVCacheFlags(avc, AFS_STALEVC_FILENAME, CUnique);
/* By this point, the vcache has been removed from all global structures
* via which someone could try to use the vcache. It is okay to drop
ReleaseWriteLock(&avc->lock);
return 0;
}
- ObtainWriteLock(&afs_xcbhash, 461);
- avc->f.states &= ~(CStatd | CUnique);
- avc->callback = NULL;
- afs_DequeueCallback(avc);
- ReleaseWriteLock(&afs_xcbhash);
+ afs_StaleVCacheFlags(avc, AFS_STALEVC_FILENAME | AFS_STALEVC_CLEARCB,
+ CUnique);
ReleaseWriteLock(&avc->lock);
- /* since we've been called back, or the callback has expired,
- * it's possible that the contents of this directory, or this
- * file's name have changed, thus invalidating the dnlc contents.
- */
- if ((avc->f.states & CForeign) || (avc->f.fid.Fid.Vnode & 1))
- osi_dnlc_purgedp(avc);
- else
- osi_dnlc_purgevp(avc);
-
/* fetch the status info */
tvc = afs_GetVCache(&avc->f.fid, areq, NULL, avc);
if (!tvc)
avc->f.m.Date = OutStatus.ClientModTime;
} else {
/* failure, set up to check with server next time */
- ObtainWriteLock(&afs_xcbhash, 462);
- afs_DequeueCallback(avc);
- avc->f.states &= ~(CStatd | CUnique); /* turn off stat valid flag */
- ReleaseWriteLock(&afs_xcbhash);
- if ((avc->f.states & CForeign) || (avc->f.fid.Fid.Vnode & 1))
- osi_dnlc_purgedp(avc); /* if it (could be) a directory */
+ afs_StaleVCacheFlags(avc, 0, CUnique);
}
ConvertWToSLock(&avc->lock);
return code;
#endif
#endif
- ObtainWriteLock(&afs_xcbhash, 464);
- tvc->f.states &= ~CUnique;
- tvc->callback = 0;
- afs_DequeueCallback(tvc);
- ReleaseWriteLock(&afs_xcbhash);
+ afs_StaleVCacheFlags(tvc, AFS_STALEVC_NODNLC | AFS_STALEVC_CLEARCB,
+ CUnique);
/* It is always appropriate to throw away all the access rights? */
afs_FreeAllAxs(&(tvc->Access));
}
if (code) {
- ObtainWriteLock(&afs_xcbhash, 465);
- afs_DequeueCallback(tvc);
- tvc->f.states &= ~(CStatd | CUnique);
- ReleaseWriteLock(&afs_xcbhash);
- if ((tvc->f.states & CForeign) || (tvc->f.fid.Fid.Vnode & 1))
- osi_dnlc_purgedp(tvc); /* if it (could be) a directory */
+ afs_StaleVCacheFlags(tvc, 0, CUnique);
if (tvp)
afs_PutVolume(tvp, READ_LOCK);
ReleaseWriteLock(&tvc->lock);
tvc->f.states &= ~CBulkFetching;
afs_QueueCallback(tvc, CBHash(3600), tvp);
} else {
- tvc->callback = NULL;
- afs_DequeueCallback(tvc);
- tvc->f.states &= ~(CStatd | CUnique);
- if ((tvc->f.states & CForeign) || (tvc->f.fid.Fid.Vnode & 1))
- osi_dnlc_purgedp(tvc); /* if it (could be) a directory */
+ afs_StaleVCacheFlags(tvc,
+ AFS_STALEVC_CBLOCKED | AFS_STALEVC_CLEARCB,
+ CUnique);
}
} else {
- afs_DequeueCallback(tvc);
- tvc->f.states &= ~CStatd;
- tvc->f.states &= ~CUnique;
- tvc->callback = NULL;
- if ((tvc->f.states & CForeign) || (tvc->f.fid.Fid.Vnode & 1))
- osi_dnlc_purgedp(tvc); /* if it (could be) a directory */
+ afs_StaleVCacheFlags(tvc,
+ AFS_STALEVC_CBLOCKED | AFS_STALEVC_CLEARCB,
+ CUnique);
}
ReleaseWriteLock(&afs_xcbhash);
if (tvp)
}
if (code) {
- ObtainWriteLock(&afs_xcbhash, 467);
- afs_DequeueCallback(tvc);
- tvc->callback = NULL;
- tvc->f.states &= ~(CStatd | CUnique);
- ReleaseWriteLock(&afs_xcbhash);
- if ((tvc->f.states & CForeign) || (tvc->f.fid.Fid.Vnode & 1))
- osi_dnlc_purgedp(tvc); /* if it (could be) a directory */
+ afs_StaleVCacheFlags(tvc, AFS_STALEVC_CLEARCB, CUnique);
ReleaseWriteLock(&tvc->lock);
afs_PutVCache(tvc);
return NULL;
afs_QueueCallback(tvc, CBHash(3600), tvolp);
}
} else {
- afs_DequeueCallback(tvc);
- tvc->callback = NULL;
- tvc->f.states &= ~(CStatd | CUnique);
- if ((tvc->f.states & CForeign) || (tvc->f.fid.Fid.Vnode & 1))
- osi_dnlc_purgedp(tvc); /* if it (could be) a directory */
+ afs_StaleVCacheFlags(tvc, AFS_STALEVC_CBLOCKED | AFS_STALEVC_CLEARCB,
+ CUnique);
}
ReleaseWriteLock(&afs_xcbhash);
afs_ProcessFS(tvc, &OutStatus, areq);
avc->f.states &= ~CBulkFetching;
afs_QueueCallback(avc, CBHash(3600), volp);
} else {
- afs_DequeueCallback(avc);
- avc->callback = NULL;
- avc->f.states &= ~(CStatd | CUnique);
- if ((avc->f.states & CForeign) || (avc->f.fid.Fid.Vnode & 1))
- osi_dnlc_purgedp(avc); /* if it (could be) a directory */
+ afs_StaleVCacheFlags(avc,
+ AFS_STALEVC_CBLOCKED | AFS_STALEVC_CLEARCB,
+ CUnique);
}
} else {
- afs_DequeueCallback(avc);
- avc->callback = NULL;
- avc->f.states &= ~(CStatd | CUnique);
- if ((avc->f.states & CForeign) || (avc->f.fid.Fid.Vnode & 1))
- osi_dnlc_purgedp(avc); /* if it (could be) a directory */
+ afs_StaleVCacheFlags(avc, AFS_STALEVC_CBLOCKED | AFS_STALEVC_CLEARCB,
+ CUnique);
}
ReleaseWriteLock(&afs_xcbhash);
if (volp)
ReleaseSharedLock(&afs_xvcache);
ObtainWriteLock(&tvc->lock, 58);
- tvc->f.states &= ~CStatd;
- if ((tvc->f.states & CForeign) || (tvc->f.fid.Fid.Vnode & 1))
- osi_dnlc_purgedp(tvc); /* if it (could be) a directory */
+ afs_StaleVCacheFlags(tvc, AFS_STALEVC_NOCB, 0);
/* Is it always appropriate to throw away all the access rights? */
afs_FreeAllAxs(&(tvc->Access));
tvc->f.states &= ~CBulkFetching;
afs_QueueCallback(tvc, CBHash(3600), tvp);
} else {
- afs_DequeueCallback(tvc);
- tvc->callback = NULL;
- tvc->f.states &= ~(CStatd | CUnique);
- if ((tvc->f.states & CForeign) || (tvc->f.fid.Fid.Vnode & 1))
- osi_dnlc_purgedp(tvc); /* if it (could be) a directory */
+ afs_StaleVCacheFlags(tvc, AFS_STALEVC_CBLOCKED | AFS_STALEVC_CLEARCB,
+ CUnique);
}
ReleaseWriteLock(&afs_xcbhash);
if (tvp)
void
afs_ResetVCache(struct vcache *avc, afs_ucred_t *acred, afs_int32 skipdnlc)
{
- ObtainWriteLock(&afs_xcbhash, 456);
- afs_DequeueCallback(avc);
- avc->f.states &= ~(CStatd | CDirty); /* next reference will re-stat */
- ReleaseWriteLock(&afs_xcbhash);
+ afs_stalevc_flags_t flags = 0;
+ if (skipdnlc) {
+ flags |= AFS_STALEVC_NODNLC;
+ }
+
+ afs_StaleVCacheFlags(avc, flags, CDirty); /* next reference will re-stat */
/* now find the disk cache entries */
afs_TryToSmush(avc, acred, 1);
- 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;
for (i = 0; i < VCSIZE; i++) {
for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
- tvc->f.states &= ~(CStatd|CUnique);
+ afs_StaleVCacheFlags(tvc, AFS_STALEVC_NODNLC | AFS_STALEVC_NOCB,
+ CUnique);
}
}
ReleaseWriteLock(&afs_xvcache);
}
+
+/**
+ * Mark a vcache as stale; our metadata for the relevant file may be out of
+ * date.
+ *
+ * @post Any subsequent access to this vcache will cause us to fetch the
+ * metadata for this vcache again.
+ */
+void
+afs_StaleVCacheFlags(struct vcache *avc, afs_stalevc_flags_t flags,
+ afs_uint32 cflags)
+{
+ int do_dnlc = 1;
+ int do_filename = 0;
+ int do_dequeue = 1;
+ int lock_cbhash = 1;
+
+ if ((flags & AFS_STALEVC_NODNLC)) {
+ do_dnlc = 0;
+ }
+ if ((flags & AFS_STALEVC_FILENAME)) {
+ do_filename = 1;
+ }
+ if ((flags & AFS_STALEVC_CBLOCKED)) {
+ lock_cbhash = 0;
+ }
+ if ((flags & AFS_STALEVC_NOCB)) {
+ do_dequeue = 0;
+ lock_cbhash = 0;
+ }
+
+ if (lock_cbhash) {
+ ObtainWriteLock(&afs_xcbhash, 486);
+ }
+ if (do_dequeue) {
+ afs_DequeueCallback(avc);
+ }
+
+ cflags |= CStatd;
+ avc->f.states &= ~cflags;
+
+ if (lock_cbhash) {
+ ReleaseWriteLock(&afs_xcbhash);
+ }
+
+ if ((flags & AFS_STALEVC_SKIP_DNLC_FOR_INIT_FLUSHED) &&
+ (avc->f.states & (CVInit | CVFlushed))) {
+ do_dnlc = 0;
+ }
+
+ if (flags & AFS_STALEVC_CLEARCB) {
+ avc->callback = NULL;
+ }
+
+ if (do_dnlc) {
+ if ((avc->f.fid.Fid.Vnode & 1) || vType(avc) == VDIR ||
+ (avc->f.states & CForeign)) {
+ /* This vcache is (or could be) a directory. */
+ osi_dnlc_purgedp(avc);
+
+ } else if (do_filename) {
+ osi_dnlc_purgevp(avc);
+ }
+ }
+}