#include "afs/afs_cbqueue.h"
#include "afs/afs_osidnlc.h"
-#if defined(AFS_OSF_ENV) || defined(AFS_LINUX22_ENV)
afs_int32 afs_maxvcount = 0; /* max number of vcache entries */
afs_int32 afs_vcount = 0; /* number of vcache in use now */
-#endif /* AFS_OSF_ENV */
#ifdef AFS_SGI_ENV
int afsvnumbers = 0;
AFS_STATCNT(afs_FlushVCache);
afs_Trace2(afs_iclSetp, CM_TRACE_FLUSHV, ICL_TYPE_POINTER, avc,
ICL_TYPE_INT32, avc->f.states);
-#ifdef AFS_OSF_ENV
- AFS_GUNLOCK();
- VN_LOCK(AFSTOV(avc));
- AFS_GLOCK();
-#endif
code = osi_VM_FlushVCache(avc, slept);
if (code)
vn_reinit(AFSTOV(avc));
#endif
afs_FreeAllAxs(&(avc->Access));
-
- /* we can't really give back callbacks on RO files, since the
- * server only tracks them on a per-volume basis, and we don't
- * know whether we still have some other files from the same
- * volume. */
- if ((avc->f.states & CRO) == 0 && avc->callback) {
- afs_QueueVCB(avc);
- }
+ afs_QueueVCB(avc);
ObtainWriteLock(&afs_xcbhash, 460);
afs_DequeueCallback(avc); /* remove it from queued callbacks list */
avc->f.states &= ~(CStatd | CUnique);
else
afs_evenZaps++;
-#if !defined(AFS_OSF_ENV) && !defined(AFS_LINUX22_ENV)
+#if !defined(AFS_LINUX22_ENV)
/* put the entry in the free list */
avc->nextfree = freeVCList;
freeVCList = avc;
afs_vcount--;
vSetType(avc, VREG);
if (VREFCOUNT_GT(avc,0)) {
-#if defined(AFS_OSF_ENV)
- VN_UNLOCK(AFSTOV(avc));
-#endif
AFS_RELE(AFSTOV(avc));
afs_stats_cmperf.vcacheXAllocs--;
} else {
if (afs_norefpanic) {
printf("flush vc refcnt < 1");
afs_norefpanic++;
-#if defined(AFS_OSF_ENV)
- (void)vgone(avc, VX_NOSLEEP, NULL);
- AFS_GLOCK();
- VN_UNLOCK(AFSTOV(avc));
-#endif
} else
osi_Panic("flush vc refcnt < 1");
}
-#endif /* AFS_OSF_ENV */
+#endif /* AFS_LINUX22_ENV */
return 0;
bad:
-#ifdef AFS_OSF_ENV
- VN_UNLOCK(AFSTOV(avc));
-#endif
return code;
-
} /*afs_FlushVCache */
#ifndef AFS_SGI_ENV
tfids = afs_osi_Alloc(sizeof(struct AFSFid) * AFS_MAXCBRSCALL);
if (lockit)
- MObtainWriteLock(&afs_xvcb, 273);
+ ObtainWriteLock(&afs_xvcb, 273);
ObtainReadLock(&afs_xserver);
for (i = 0; i < NSERVERS; i++) {
for (safety1 = 0, tsp = afs_servers[i];
cbArray.AFSCBs_val = callBacks;
memset(&callBacks[0], 0, sizeof(callBacks[0]));
callBacks[0].CallBackType = CB_EXCLUSIVE;
- for (safety3 = 0; safety3 < MAXHOSTS * 2; safety3++) {
+ for (safety3 = 0; safety3 < AFS_MAXHOSTS * 2; safety3++) {
tc = afs_ConnByHost(tsp, tsp->cell->fsport,
tsp->cell->cellNum, &treq, 0,
SHARED_LOCK);
ReleaseReadLock(&afs_xserver);
if (lockit)
- MReleaseWriteLock(&afs_xvcb);
+ ReleaseWriteLock(&afs_xvcb);
afs_osi_Free(tfids, sizeof(struct AFSFid) * AFS_MAXCBRSCALL);
return 0;
}
* Called when the xvcache lock is already held.
*
* \param avc vcache entry
- * \return 0 for success < 0 otherwise.
+ * \return 1 if queued, 0 otherwise
*/
static afs_int32
afs_QueueVCB(struct vcache *avc)
{
+ int queued = 0;
struct server *tsp;
struct afs_cbr *tcbp;
AFS_STATCNT(afs_QueueVCB);
+
+ ObtainWriteLock(&afs_xvcb, 274);
+
+ /* we can't really give back callbacks on RO files, since the
+ * server only tracks them on a per-volume basis, and we don't
+ * know whether we still have some other files from the same
+ * volume. */
+ if (!((avc->f.states & CRO) == 0 && avc->callback)) {
+ goto done;
+ }
+
/* The callback is really just a struct server ptr. */
tsp = (struct server *)(avc->callback);
/* we now have a pointer to the server, so we just allocate
* a queue entry and queue it.
*/
- MObtainWriteLock(&afs_xvcb, 274);
tcbp = afs_AllocCBR();
tcbp->fid = avc->f.fid.Fid;
tcbp->pprev = &tsp->cbrs;
afs_InsertHashCBR(tcbp);
+ queued = 1;
+ done:
/* now release locks and return */
- MReleaseWriteLock(&afs_xvcb);
- return 0;
+ ReleaseWriteLock(&afs_xvcb);
+ return queued;
}
struct afs_cbr *cbr, *ncbr;
AFS_STATCNT(afs_RemoveVCB);
- MObtainWriteLock(&afs_xvcb, 275);
+ ObtainWriteLock(&afs_xvcb, 275);
slot = afs_HashCBRFid(&afid->Fid);
ncbr = afs_cbrHashT[slot];
}
}
- MReleaseWriteLock(&afs_xvcb);
+ ReleaseWriteLock(&afs_xvcb);
}
void
int
afs_ShakeLooseVCaches(afs_int32 anumber)
{
-#if defined(AFS_OSF_ENV) || defined(AFS_LINUX22_ENV)
+#if defined(AFS_LINUX22_ENV)
afs_int32 i;
struct vcache *tvc;
struct afs_q *tq, *uq;
int code, fv_slept;
afs_int32 target = anumber;
- int haveGlock = 1;
-
- /* Should probably deal better */
- if (!ISAFS_GLOCK()) {
- haveGlock = 0;
- AFS_GLOCK();
- }
if (afsd_dynamic_vcaches || afs_vcount >= afs_maxvcount) {
i = 0;
/*
printf("recycled %d entries\n", target-anumber);
*/
- if (!haveGlock)
- AFS_GUNLOCK();
#endif
return 0;
}
afs_AllocVCache(void)
{
struct vcache *tvc;
-#if defined(AFS_OSF30_ENV)
- struct vcache *nvc;
- AFS_GUNLOCK();
- if (getnewvnode(MOUNT_AFS, &Afs_vnodeops, &nvc)) {
- /* What should we do ???? */
- osi_Panic("afs_AllocVCache: no more vnodes");
- }
- AFS_GLOCK();
-
- tvc = nvc;
- tvc->nextfree = NULL;
- afs_vcount++;
-#elif defined(AFS_LINUX22_ENV)
+#if defined(AFS_LINUX22_ENV)
struct inode *ip;
AFS_GUNLOCK();
/* none free, making one is better than a panic */
afs_stats_cmperf.vcacheXAllocs++; /* count in case we have a leak */
tvc = (struct vcache *)afs_osi_Alloc(sizeof(struct vcache));
-#if defined(AFS_DARWIN_ENV) && !defined(UKERNEL)
+#if (defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)) && !defined(UKERNEL)
tvc->v = NULL; /* important to clean this, or use memset 0 */
-#endif
+#endif /* DARWIN || XBSD && !UKERNEL */
#ifdef KERNEL_HAVE_PIN
pin((char *)tvc, sizeof(struct vcache)); /* XXX */
#endif
#ifdef AFS_AIX_ENV
struct gnode *gnodepnt;
#endif
-#if !defined(AFS_OSF_ENV) && !defined(AFS_LINUX22_ENV)
+#if !defined(AFS_LINUX22_ENV)
struct afs_q *tq, *uq;
int code, fv_slept;
#endif
afs_FlushReclaimedVcaches();
-#if defined(AFS_OSF_ENV) || defined(AFS_LINUX22_ENV)
+#if defined(AFS_LINUX22_ENV)
if(!afsd_dynamic_vcaches) {
afs_ShakeLooseVCaches(anumber);
if (afs_vcount >= afs_maxvcount) {
}
}
tvc = afs_AllocVCache();
-#else /* AFS_OSF_ENV */
+#else /* AFS_LINUX22_ENV */
/* pull out a free cache entry */
if (!freeVCList) {
int loop = 0;
* XXX assume FreeBSD is the same for now.
*/
AFS_GUNLOCK();
+#if defined(AFS_FBSD80_ENV)
+ /* vgone() is correct, but v_usecount is assumed not
+ * to be 0, and I suspect that currently our usage ensures that
+ * in fact it will */
+ if (vrefcnt(AFSTOV(tvc)) < 1) {
+ vref(AFSTOV(tvc));
+ }
+ vn_lock(AFSTOV(tvc), LK_EXCLUSIVE | LK_RETRY); /* !glocked */
+#endif
vgone(AFSTOV(tvc));
+#if defined(AFS_FBSD80_ENV)
+ VOP_UNLOCK(AFSTOV(tvc), 0);
+#endif
fv_slept = 0;
code = 0;
AFS_GLOCK();
tvc->nextfree = NULL;
} /* end of if (!freeVCList) */
-#endif /* AFS_OSF_ENV */
+#endif /* AFS_LINUX22_ENV */
#if defined(AFS_XBSD_ENV) || defined(AFS_DARWIN_ENV)
if (tvc->v)
panic("afs_NewVCache(): free vcache with vnode attached");
#endif
-#if !defined(AFS_SGI_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_LINUX22_ENV)
+#if !defined(AFS_SGI_ENV) && !defined(AFS_LINUX22_ENV)
#if defined(AFS_DISCON_ENV)
/* We need to preserve the slot that we're being stored into on
if (getnewvnode(VT_AFS, afs_globalVFS, afs_vnodeop_p, &vp))
#endif
panic("afs getnewvnode"); /* can't happen */
+#ifdef AFS_FBSD70_ENV
+ /* XXX verified on 80--TODO check on 7x */
+ if (!vp->v_mount) {
+ vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); /* !glocked */
+ insmntque(vp, afs_globalVFS);
+ VOP_UNLOCK(vp, 0);
+ }
+#endif
AFS_GLOCK();
ObtainWriteLock(&afs_xvcache,339);
if (tvc->v != NULL) {
}
#endif
-#if defined(AFS_OSF_ENV) || defined(AFS_LINUX22_ENV)
+#if defined(AFS_LINUX22_ENV)
/* Hold it for the LRU (should make count 2) */
VN_HOLD(AFSTOV(tvc));
-#else /* AFS_OSF_ENV */
-#if !(defined (AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV))
+#elif !(defined (AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV))
VREFCOUNT_SET(tvc, 1); /* us */
-#endif /* AFS_XBSD_ENV */
-#endif /* AFS_OSF_ENV */
+#endif
+
#ifdef AFS_AIX32_ENV
LOCK_INIT(&tvc->pvmlock, "vcache pvmlock");
tvc->vmh = tvc->segid = NULL;
#endif
vnode_pcache_init(&tvc->v);
#if defined(DEBUG) && defined(VNODE_INIT_BITLOCK)
- /* Above define is never true execpt in SGI test kernels. */
- init_bitlock(&(tvc->v.v_flag, VLOCK, "vnode", tvc->v.v_number);
+ /* Above define is never true except in SGI test kernels. */
+ init_bitlock(&(tvc->v.v_flag, VLOCK, "vnode", tvc->v.v_number));
#endif
#ifdef INTR_KTHREADS
- AFS_VN_INIT_BUF_LOCK(&(tvc->v));
+ AFS_VN_INIT_BUF_LOCK(&(tvc->v));
#endif
#else
SetAfsVnode(AFSTOV(tvc));
tvc->v.v_next = gnodepnt->gn_vnode; /*Single vnode per gnode for us! */
gnodepnt->gn_vnode = &tvc->v;
#endif
-#if defined(AFS_DUX40_ENV)
- insmntque(tvc, afs_globalVFS, &afs_ubcops);
-#else
-#ifdef AFS_OSF_ENV
- /* Is this needed??? */
- insmntque(tvc, afs_globalVFS);
-#endif /* AFS_OSF_ENV */
-#endif /* AFS_DUX40_ENV */
-#ifdef AFS_FBSD70_ENV
-#ifndef AFS_FBSD80_ENV /* yup. they put it back. */
- insmntque(AFSTOV(tvc), afs_globalVFS);
-#endif
-#endif
#if defined(AFS_SGI_ENV)
VN_SET_DPAGES(&(tvc->v), (struct pfdat *)NULL);
osi_Assert((tvc->v.v_flag & VINACT) == 0);
AFS_STATCNT(afs_VerifyVCache);
-#if defined(AFS_OSF_ENV)
- ObtainReadLock(&avc->lock);
- if (afs_IsWired(avc)) {
- ReleaseReadLock(&avc->lock);
- return 0;
- }
- ReleaseReadLock(&avc->lock);
-#endif /* AFS_OSF_ENV */
/* otherwise we must fetch the status info */
ObtainWriteLock(&avc->lock, 53);
ReleaseWriteLock(&tvc->lock);
return tvc;
}
-#if defined(AFS_OSF_ENV)
- if (afs_IsWired(tvc)) {
- ReleaseWriteLock(&tvc->lock);
- return tvc;
- }
-#endif /* AFS_OSF_ENV */
#ifdef AFS_DARWIN80_ENV
/* Darwin 8.0 only has bufs in nfs, so we shouldn't have to worry about them.
What about ubc? */
if (glocked)
AFS_GLOCK();
}
- vinvalbuf(vp, V_SAVE, curthread, PINOD, 0);
+ vinvalbuf(vp, V_SAVE, PINOD, 0); /* changed late in 8.0-CURRENT */
if (!iheldthelock)
VOP_UNLOCK(vp, 0);
#elif defined(AFS_FBSD60_ENV)
struct AFSCallBack CallBack;
struct AFSVolSync tsync;
int origCBs = 0;
-#ifdef AFS_OSF_ENV
- int vg;
-#endif
#ifdef AFS_DARWIN80_ENV
vnode_t tvp;
#endif
afs_osi_Sleep(&tvc->f.states);
goto rootvc_loop;
}
-#ifdef AFS_OSF_ENV
- /* Grab this vnode, possibly reactivating from the free list */
- /* for the present (95.05.25) everything on the hash table is
- * definitively NOT in the free list -- at least until afs_reclaim
- * can be safely implemented */
- AFS_GUNLOCK();
- vg = vget(AFSTOV(tvc)); /* this bumps ref count */
- AFS_GLOCK();
- if (vg)
- continue;
-#endif /* AFS_OSF_ENV */
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
ReleaseSharedLock(&afs_xvcache);
if (!haveStatus && (!tvc || !(tvc->f.states & CStatd))) {
/* Mount point no longer stat'd or unknown. FID may have changed. */
-#ifdef AFS_OSF_ENV
- if (tvc)
- AFS_RELE(AFSTOV(tvc));
-#endif
getNewFid = 1;
ReleaseSharedLock(&afs_xvcache);
#ifdef AFS_DARWIN80_ENV
if (cached)
*cached = 1;
afs_stats_cmperf.vcacheHits++;
-#if defined(AFS_OSF_ENV) || defined(AFS_DARWIN80_ENV)
+#if defined(AFS_DARWIN80_ENV)
/* we already bumped the ref count in the for loop above */
-#else /* AFS_OSF_ENV */
+#else /* AFS_DARWIN80_ENV */
osi_vnhold(tvc, 0);
#endif
UpgradeSToWLock(&afs_xvcache, 24);
register struct vcache *tvc;
afs_int32 i;
-#if defined( AFS_OSF_ENV)
- int vg;
-#endif
#ifdef AFS_DARWIN80_ENV
vnode_t tvp;
#endif
findvc_sleep(tvc, flag);
goto findloop;
}
-#ifdef AFS_OSF_ENV
- /* Grab this vnode, possibly reactivating from the free list */
- AFS_GUNLOCK();
- vg = vget(AFSTOV(tvc));
- AFS_GLOCK();
- if (vg)
- continue;
-#endif /* AFS_OSF_ENV */
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
findvc_sleep(tvc, flag);
if (tvc) {
if (retry)
*retry = 0;
-#if !defined(AFS_OSF_ENV) && !defined(AFS_DARWIN80_ENV)
+#if !defined(AFS_DARWIN80_ENV)
osi_vnhold(tvc, retry); /* already held, above */
if (retry && *retry)
return 0;
afs_int32 i;
afs_int32 count = 0;
struct vcache *found_tvc = NULL;
-#ifdef AFS_OSF_ENV
- int vg;
-#endif
#ifdef AFS_DARWIN80_ENV
vnode_t tvp;
#endif
afs_osi_Sleep(&tvc->f.states);
goto loop;
}
-#ifdef AFS_OSF_ENV
- /* Grab this vnode, possibly reactivating from the free list */
- AFS_GUNLOCK();
- vg = vget(AFSTOV(tvc));
- AFS_GLOCK();
- if (vg) {
- /* This vnode no longer exists. */
- continue;
- }
-#endif /* AFS_OSF_ENV */
#ifdef AFS_DARWIN80_ENV
if (tvc->f.states & CDeadVnode) {
ReleaseSharedLock(&afs_xvcache);
count++;
if (found_tvc) {
/* Duplicates */
-#ifdef AFS_OSF_ENV
- /* Drop our reference counts. */
- vrele(AFSTOV(tvc));
- vrele(AFSTOV(found_tvc));
-#endif
afs_duplicate_nfs_fids++;
ReleaseSharedLock(&afs_xvcache);
#ifdef AFS_DARWIN80_ENV
goto loop;
}
#else
-#if !defined(AFS_OSF_ENV)
osi_vnhold(tvc, (int *)0); /* already held, above */
#endif
-#endif
/*
* We obtained the xvcache lock above.
*/
void
afs_vcacheInit(int astatSize)
{
-#if (!defined(AFS_OSF_ENV) && !defined(AFS_LINUX22_ENV)) || defined(AFS_SGI_ENV)
+#if !defined(AFS_LINUX22_ENV)
register struct vcache *tvp;
#endif
int i;
-#if defined(AFS_OSF_ENV) || defined(AFS_LINUX22_ENV)
- if (!afs_maxvcount) {
#if defined(AFS_LINUX22_ENV)
+ if (!afs_maxvcount) {
afs_maxvcount = astatSize; /* no particular limit on linux? */
-#elif defined(AFS_OSF30_ENV)
- afs_maxvcount = max_vnodes / 2; /* limit ourselves to half the total */
-#else
- afs_maxvcount = nvnode / 2; /* limit ourselves to half the total */
-#endif
if (astatSize < afs_maxvcount) {
afs_maxvcount = astatSize;
}
}
-#else /* AFS_OSF_ENV */
+#else /* AFS_LINUX22_ENV */
freeVCList = NULL;
#endif
AFS_RWLOCK_INIT(&afs_xvcache, "afs_xvcache");
LOCK_INIT(&afs_xvcb, "afs_xvcb");
-#if !defined(AFS_OSF_ENV) && !defined(AFS_LINUX22_ENV)
+#if !defined(AFS_LINUX22_ENV)
/* Allocate and thread the struct vcache entries */
tvp = (struct vcache *)afs_osi_Alloc(astatSize * sizeof(struct vcache));
memset(tvp, 0, sizeof(struct vcache) * astatSize);
tvp[i].nextfree = &(tvp[i + 1]);
}
tvp[astatSize - 1].nextfree = NULL;
-#ifdef KERNEL_HAVE_PIN
+# ifdef KERNEL_HAVE_PIN
pin((char *)tvp, astatSize * sizeof(struct vcache)); /* XXX */
-#endif
+# endif
#endif
#if defined(AFS_SGI_ENV)
}
afs_cbrSpace = 0;
-#if !defined(AFS_OSF_ENV) && !defined(AFS_LINUX22_ENV)
+#if !defined(AFS_LINUX22_ENV)
afs_osi_Free(Initial_freeVCList, afs_cacheStats * sizeof(struct vcache));
-#endif
-#ifdef KERNEL_HAVE_PIN
+
+# ifdef KERNEL_HAVE_PIN
unpin(Initial_freeVCList, afs_cacheStats * sizeof(struct vcache));
-#endif
+# endif
-#if !defined(AFS_OSF_ENV) && !defined(AFS_LINUX22_ENV)
freeVCList = Initial_freeVCList = 0;
#endif
+
AFS_RWLOCK_INIT(&afs_xvcache, "afs_xvcache");
LOCK_INIT(&afs_xvcb, "afs_xvcb");
QInit(&VLRU);
/* Somehow, walk the set of vcaches, with each one coming out as tvc */
for (i = 0; i < VCSIZE; i++) {
for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) {
- if ((tvc->f.states & CRO) == 0 && tvc->callback) {
- afs_QueueVCB(tvc);
+ if (afs_QueueVCB(tvc)) {
tvc->callback = NULL;
nq++;
}
}
}
- /*printf("%d callbacks to be discarded. queued ... ", nq);*/
- afs_FlushVCBs(0);
-
+
ReleaseWriteLock(&afs_xvcache);
- /*printf("gone\n");*/
+
+ afs_FlushVCBs(1);
}
/*!
git://git.openafs.org / openafs.git / blobdiff