From d2ec7c34b983d4eb246f30a51eb3e54353a99565 Mon Sep 17 00:00:00 2001 From: Jim Rees Date: Fri, 8 Nov 2002 21:59:23 +0000 Subject: [PATCH] openbsd-20021108 More OpenBSD merge. Fix refcount screwups in afs_GetVCache and friends. "ls -ld /afs" works now. --- src/afs/OBSD/osi_machdep.h | 5 +- src/afs/afs_osi.c | 38 ++-- src/afs/afs_osi.h | 2 +- src/afs/afs_vcache.c | 447 +++++++++++++++++++------------------ 4 files changed, 244 insertions(+), 248 deletions(-) diff --git a/src/afs/OBSD/osi_machdep.h b/src/afs/OBSD/osi_machdep.h index 1001e676a..c3181f6cd 100644 --- a/src/afs/OBSD/osi_machdep.h +++ b/src/afs/OBSD/osi_machdep.h @@ -45,9 +45,7 @@ extern struct timeval time; #define afs_bufferpages bufpages -#define osi_vnhold(avc,r) do { \ - if ((avc)->vrefCount) { VN_HOLD((struct vnode *)(avc)); } \ - else osi_Panic("refcnt==0"); } while(0) +#define osi_vnhold(avc, r) afs_vget(AFSTOV(avc), 0) #define gop_rdwr(rw,gp,base,len,offset,segflg,unit,cred,aresid) \ vn_rdwr((rw),(gp),(base),(len),(offset),(segflg),(unit),(cred),(aresid), curproc) @@ -60,6 +58,7 @@ extern int (**afs_vnodeop_p)(); #define AFS_HOLD(vp) afs_nbsd_ref(vp) #define AFS_RELE(vp) afs_nbsd_rele(vp) +extern int afs_vget(); extern void afs_nbsd_ref(struct vnode *); extern void afs_nbsd_rele(struct vnode *); diff --git a/src/afs/afs_osi.c b/src/afs/afs_osi.c index 01f3980f9..983fbffe3 100644 --- a/src/afs/afs_osi.c +++ b/src/afs/afs_osi.c @@ -53,20 +53,18 @@ void osi_Init(void) #elif defined(AFS_OSF_ENV) usimple_lock_init(&afs_global_lock); afs_global_owner = (thread_t)0; -#elif defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) +#elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) lockinit(&afs_global_lock, PLOCK, "afs global lock", 0, 0); afs_global_owner = 0; #elif defined(AFS_AIX41_ENV) lock_alloc((void*)&afs_global_lock, LOCK_ALLOC_PIN, 1, 1); simple_lock_init((void *)&afs_global_lock); -#else -#ifndef AFS_LINUX22_ENV +#elif !defined(AFS_LINUX22_ENV) /* Linux initialization in osi directory. Should move the others. */ mutex_init(&afs_global_lock, "afs_global_lock", MUTEX_DEFAULT, NULL); -#endif #endif /* afs_rxglobal_lock is initialized in rx_Init. */ -#endif +#endif /* AFS_GLOBAL_SUNLOCK */ #endif /* AFS_HPUX_ENV */ if ( !afs_osicred_initialized ) { @@ -82,19 +80,15 @@ void osi_Init(void) int osi_Active(register struct vcache *avc) { AFS_STATCNT(osi_Active); -#if defined(AFS_SUN_ENV) || defined(AFS_AIX_ENV) || defined(AFS_OSF_ENV) || defined(AFS_SUN5_ENV) || (AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) +#if defined(AFS_SUN_ENV) || defined(AFS_AIX_ENV) || defined(AFS_OSF_ENV) || defined(AFS_SUN5_ENV) || (AFS_LINUX20_ENV) || defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) if ((avc->opens > 0) || (avc->states & CMAPPED)) return 1; /* XXX: Warning, verify this XXX */ -#else -#if defined(AFS_MACH_ENV) +#elif defined(AFS_MACH_ENV) if (avc->opens > 0 || ((avc->v.v_flag & VTEXT) && !inode_uncache_try(avc))) return 1; -#else -#if defined(AFS_SGI_ENV) +#elif defined(AFS_SGI_ENV) if ((avc->opens > 0) || AFS_VN_MAPPED(AFSTOV(avc))) return 1; #else if (avc->opens > 0 || (AFSTOV(avc)->v_flag & VTEXT)) return(1); -#endif -#endif /* AFS_MACH_ENV */ #endif return 0; } @@ -304,26 +298,20 @@ void afs_osi_Invisible(void) { #ifdef AFS_LINUX22_ENV afs_osi_MaskSignals(); -#endif -#ifdef AFS_DEC_ENV +#elif defined(AFS_DEC_ENV) u.u_procp->p_type |= SSYS; -#endif -#if AFS_SUN5_ENV +#elif defined(AFS_SUN5_ENV) curproc->p_flag |= SSYS; -#endif -#if AFS_HPUX101_ENV +#elif defined(AFS_HPUX101_ENV) set_system_proc(u.u_procp); -#endif -#if defined(AFS_DARWIN_ENV) +#elif defined(AFS_DARWIN_ENV) /* maybe call init_process instead? */ current_proc()->p_flag |= P_SYSTEM; -#endif -#if defined(AFS_FBSD_ENV) +#elif defined(AFS_XBSD_ENV) curproc->p_flag |= P_SYSTEM; -#endif -#if defined(AFS_SGI_ENV) +#elif defined(AFS_SGI_ENV) vrelvm(); -#endif /* AFS_SGI_ENV */ +#endif AFS_STATCNT(osi_Invisible); } diff --git a/src/afs/afs_osi.h b/src/afs/afs_osi.h index 37c407da3..32a284a2c 100644 --- a/src/afs/afs_osi.h +++ b/src/afs/afs_osi.h @@ -244,7 +244,7 @@ typedef struct timeval osi_timeval_t; * (Also, of course, the vnode is assumed to be one of ours. Can't use this * macro for V-file vnodes.) */ -#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV) +#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV) /* Bare refcount manipulation would probably work on this platform, but just calling VREF does not */ #define AFS_FAST_HOLD(vp) osi_vnhold((vp),0) diff --git a/src/afs/afs_vcache.c b/src/afs/afs_vcache.c index ef21a4dfd..f66ace77d 100644 --- a/src/afs/afs_vcache.c +++ b/src/afs/afs_vcache.c @@ -1,7 +1,7 @@ /* * Copyright 2000, International Business Machines Corporation and others. * All Rights Reserved. - * + * * This software has been released under the terms of the IBM Public * License. For details, see the LICENSE file in the top-level source * directory or online at http://www.openafs.org/dl/license10.html @@ -58,7 +58,7 @@ int afsvnumbers = 0; #ifdef AFS_SGI64_ENV char *makesname(); #endif /* AFS_SGI64_ENV */ - + /* Exported variables */ afs_rwlock_t afs_xvcache; /*Lock: alloc new stat cache entries*/ afs_lock_t afs_xvcb; /*Lock: fids on which there are callbacks*/ @@ -89,7 +89,7 @@ static afs_int32 afs_QueueVCB(struct vcache *avc); * afs_xvcache lock must be held for writing upon entry to * prevent people from changing the vrefCount field, and to * protect the lruq and hnext fields. - * LOCK: afs_FlushVCache afs_xvcache W + * LOCK: afs_FlushVCache afs_xvcache W * REFCNT: vcache ref count must be zero on entry except for osf1 * RACE: lock is dropped and reobtained, permitting race in caller */ @@ -146,12 +146,20 @@ int afs_FlushVCache(struct vcache *avc, int *slept) if (avc->mvid) osi_FreeSmallSpace(avc->mvid); avc->mvid = (struct VenusFid*)0; if (avc->linkData) { - afs_osi_Free(avc->linkData, strlen(avc->linkData)+1); - avc->linkData = NULL; + afs_osi_Free(avc->linkData, strlen(avc->linkData)+1); + avc->linkData = NULL; } +#if defined(AFS_OBSD_ENV) + /* OK, there are no internal vrefCounts, so there shouldn't + be any more refs here. */ + if (avc->v) { + avc->v->v_data = NULL; /* remove from vnode */ + avc->v = NULL; /* also drop the ptr to vnode */ + } +#endif afs_FreeAllAxs(&(avc->Access)); - /* we can't really give back callbacks on RO files, since the + /* 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. */ @@ -163,10 +171,10 @@ int afs_FlushVCache(struct vcache *avc, int *slept) avc->states &= ~(CStatd | CUnique); ReleaseWriteLock(&afs_xcbhash); afs_symhint_inval(avc); - if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1)) - osi_dnlc_purgedp (avc); /* if it (could be) a directory */ - else - osi_dnlc_purgevp (avc); + if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1)) + osi_dnlc_purgedp (avc); /* if it (could be) a directory */ + else + osi_dnlc_purgevp (avc); /* * Next, keep track of which vnodes we've deleted for create's @@ -183,7 +191,7 @@ int afs_FlushVCache(struct vcache *avc, int *slept) if (avc->vlruq.prev || avc->vlruq.next) { refpanic ("LRU vs. Free inconsistency"); } -#else +#else /* This should put it back on the vnode free list since usecount is 1 */ afs_vcount--; vSetType(avc, VREG); @@ -228,9 +236,9 @@ void afs_InactiveVCache(struct vcache *avc, struct AFS_UCRED *acred) avc->states &= ~CMAPPED; /* mainly used by SunOS 4.0.x */ avc->states &= ~CDirty; /* Turn it off */ if (avc->states & CUnlinked) { - if (CheckLock(&afs_xvcache) || CheckLock(&afs_xdcache)) { + if (CheckLock(&afs_xvcache) || CheckLock(&afs_xdcache)) { avc->states |= CUnlinkedDel; - return; + return; } afs_remunlink(avc, 1); /* ignore any return code */ } @@ -302,7 +310,7 @@ int afs_FreeCBR(register struct afs_cbr *asp) * Environment: holds xvcb lock over RPC to guard against race conditions * when a new callback is granted for the same file later on. */ -afs_int32 afs_FlushVCBs (afs_int32 lockit) +afs_int32 afs_FlushVCBs (afs_int32 lockit) { struct AFSFid tfids[AFS_MAXCBRSCALL]; struct AFSCallBack callBacks[1]; @@ -325,7 +333,7 @@ afs_int32 afs_FlushVCBs (afs_int32 lockit) ObtainReadLock(&afs_xserver); for(i=0; inext, safety1++) { + tsp && safety1 < afs_totalServers+10; tsp=tsp->next, safety1++) { /* don't have any */ if (tsp->cbrs == (struct afs_cbr *) 0) continue; @@ -521,7 +529,7 @@ resume: * All done at this level ... ascend and resume the search. */ if (this_parent != parent) { - next = this_parent->d_child.next; + next = this_parent->d_child.next; this_parent = this_parent->d_parent; goto resume; } @@ -568,7 +576,7 @@ static void afs_TryFlushDcacheChildren(struct vcache *tvc) struct list_head *cur; struct list_head *head = &ip->i_dentry; struct dentry *dentry; - + AFS_GUNLOCK(); restart: #ifndef old_vcache_scheme @@ -576,7 +584,7 @@ restart: cur = head; while ((cur = cur->next) != head) { dentry = list_entry(cur, struct dentry, d_alias); - + afs_Trace3(afs_iclSetp, CM_TRACE_TRYFLUSHDCACHECHILDREN, ICL_TYPE_POINTER, ip, ICL_TYPE_STRING, dentry->d_parent->d_name.name, @@ -636,7 +644,7 @@ restart: * afid : The file id of the file whose cache entry is being * created. */ -/* LOCK: afs_NewVCache afs_xvcache W */ +/* LOCK: afs_NewVCache afs_xvcache W */ struct vcache *afs_NewVCache(struct VenusFid *afid, struct server *serverp) { struct vcache *tvc; @@ -657,58 +665,57 @@ struct vcache *afs_NewVCache(struct VenusFid *afid, struct server *serverp) AFS_STATCNT(afs_NewVCache); #ifdef AFS_OSF_ENV #ifdef AFS_OSF30_ENV - if (afs_vcount >= afs_maxvcount) + if (afs_vcount >= afs_maxvcount) { #else /* * If we are using > 33 % of the total system vnodes for AFS vcache * entries or we are using the maximum number of vcache entries, * then free some. (if our usage is > 33% we should free some, if - * our usage is > afs_maxvcount, set elsewhere to 0.5*nvnode, + * our usage is > afs_maxvcount, set elsewhere to 0.5*nvnode, * we _must_ free some -- no choice). */ - if ( (( 3 * afs_vcount ) > nvnode) || ( afs_vcount >= afs_maxvcount )) + if ( (( 3 * afs_vcount ) > nvnode) || ( afs_vcount >= afs_maxvcount )) { #endif - { - struct afs_q *tq, *uq; - int i; char *panicstr; + struct afs_q *tq, *uq; + int i; char *panicstr; - i = 0; - for(tq = VLRU.prev; tq != &VLRU && anumber > 0; tq = uq) { + i = 0; + for (tq = VLRU.prev; tq != &VLRU && anumber > 0; tq = uq) { tvc = QTOV(tq); uq = QPrev(tq); - if (tvc->states & CVFlushed) - refpanic ("CVFlushed on VLRU"); + if (tvc->states & CVFlushed) + refpanic ("CVFlushed on VLRU"); else if (i++ > afs_maxvcount) - refpanic ("Exceeded pool of AFS vnodes(VLRU cycle?)"); + refpanic ("Exceeded pool of AFS vnodes(VLRU cycle?)"); else if (QNext(uq) != tq) - refpanic ("VLRU inconsistent"); - else if (VREFCOUNT(tvc) < 1) - refpanic ("refcnt 0 on VLRU"); + refpanic ("VLRU inconsistent"); + else if (VREFCOUNT(tvc) < 1) + refpanic ("refcnt 0 on VLRU"); - if ( VREFCOUNT(tvc) == 1 && tvc->opens == 0 + if ( VREFCOUNT(tvc) == 1 && tvc->opens == 0 && (tvc->states & CUnlinkedDel) == 0) { code = afs_FlushVCache(tvc, &fv_slept); if (code == 0) { - anumber--; + anumber--; } if (fv_slept) { - uq = VLRU.prev; - i = 0; - continue; /* start over - may have raced. */ + uq = VLRU.prev; + i = 0; + continue; /* start over - may have raced. */ } } if (tq == uq) break; - } - if (anumber == VCACHE_FREE) { - printf("NewVCache: warning none freed, using %d of %d\n", + } + if (anumber == VCACHE_FREE) { + printf("NewVCache: warning none freed, using %d of %d\n", afs_vcount, afs_maxvcount); if (afs_vcount >= afs_maxvcount) { osi_Panic("NewVCache - none freed"); - /* XXX instead of panicing, should do afs_maxvcount++ + /* XXX instead of panicing, should do afs_maxvcount++ and magic up another one */ } - } - } + } + } AFS_GUNLOCK(); if (getnewvnode(MOUNT_AFS, &Afs_vnodeops, &nvc)) { @@ -718,69 +725,69 @@ struct vcache *afs_NewVCache(struct VenusFid *afid, struct server *serverp) AFS_GLOCK(); tvc = nvc; - tvc->nextfree = NULL; + tvc->nextfree = NULL; afs_vcount++; #else /* AFS_OSF_ENV */ /* pull out a free cache entry */ if (!freeVCList) { i = 0; - for(tq = VLRU.prev; (anumber > 0) && (tq != &VLRU); tq = uq) { - tvc = QTOV(tq); - uq = QPrev(tq); + for (tq = VLRU.prev; (anumber > 0) && (tq != &VLRU); tq = uq) { + tvc = QTOV(tq); + uq = QPrev(tq); - if (tvc->states & CVFlushed) { + if (tvc->states & CVFlushed) { refpanic("CVFlushed on VLRU"); - } else if (i++ > 2*afs_cacheStats) { /* even allowing for a few xallocs...*/ + } else if (i++ > 2*afs_cacheStats) { /* even allowing for a few xallocs...*/ refpanic("Increase -stat parameter of afsd(VLRU cycle?)"); - } else if (QNext(uq) != tq) { + } else if (QNext(uq) != tq) { refpanic("VLRU inconsistent"); - } + } #ifdef AFS_DARWIN_ENV - if (tvc->opens == 0 && ((tvc->states & CUnlinkedDel) == 0) && + if (tvc->opens == 0 && ((tvc->states & CUnlinkedDel) == 0) && VREFCOUNT(tvc) == 1 && UBCINFOEXISTS(&tvc->v)) { - osi_VM_TryReclaim(tvc, &fv_slept); - if (fv_slept) { - uq = VLRU.prev; - i = 0; - continue; /* start over - may have raced. */ - } + osi_VM_TryReclaim(tvc, &fv_slept); + if (fv_slept) { + uq = VLRU.prev; + i = 0; + continue; /* start over - may have raced. */ + } } #endif #if defined(AFS_FBSD_ENV) - if (VREFCOUNT(tvc) == 1 && tvc->opens == 0 - && (tvc->states & CUnlinkedDel) == 0) { - if (!(VOP_LOCK(&tvc->v, LK_EXCLUSIVE, curproc))) { - if (VREFCOUNT(tvc) == 1 && tvc->opens == 0 - && (tvc->states & CUnlinkedDel) == 0) { - VREFCOUNT_DEC(tvc); - AFS_GUNLOCK(); /* perhaps inline inactive for locking */ - VOP_INACTIVE(&tvc->v, curproc); - AFS_GLOCK(); - } else { - VOP_UNLOCK(&tvc->v, 0, curproc); - } - } - } + if (VREFCOUNT(tvc) == 1 && tvc->opens == 0 + && (tvc->states & CUnlinkedDel) == 0) { + if (!(VOP_LOCK(&tvc->v, LK_EXCLUSIVE, curproc))) { + if (VREFCOUNT(tvc) == 1 && tvc->opens == 0 + && (tvc->states & CUnlinkedDel) == 0) { + VREFCOUNT_DEC(tvc); + AFS_GUNLOCK(); /* perhaps inline inactive for locking */ + VOP_INACTIVE(&tvc->v, curproc); + AFS_GLOCK(); + } else { + VOP_UNLOCK(&tvc->v, 0, curproc); + } + } + } #endif #if defined(AFS_LINUX22_ENV) if (tvc != afs_globalVp && VREFCOUNT(tvc) && tvc->opens == 0) afs_TryFlushDcacheChildren(tvc); #endif - if (VREFCOUNT(tvc) == 0 && tvc->opens == 0 - && (tvc->states & CUnlinkedDel) == 0) { + if (VREFCOUNT(tvc) == 0 && tvc->opens == 0 + && (tvc->states & CUnlinkedDel) == 0) { code = afs_FlushVCache(tvc, &fv_slept); if (code == 0) { - anumber--; + anumber--; } if (fv_slept) { - uq = VLRU.prev; - i = 0; - continue; /* start over - may have raced. */ + uq = VLRU.prev; + i = 0; + continue; /* start over - may have raced. */ } - } - if (tq == uq ) break; + } + if (tq == uq ) break; } } if (!freeVCList) { @@ -888,7 +895,7 @@ struct vcache *afs_NewVCache(struct VenusFid *afid, struct server *serverp) #if defined(AFS_SUN55_ENV) /* This is required if the kaio (kernel aynchronous io) ** module is installed. Inside the kernel, the function - ** check_vp( common/os/aio.c) checks to see if the kernel has + ** check_vp( common/os/aio.c) checks to see if the kernel has ** to provide asynchronous io for this vnode. This ** function extracts the device number by following the ** v_data field of the vnode. If we do not set this field @@ -946,17 +953,17 @@ struct vcache *afs_NewVCache(struct VenusFid *afid, struct server *serverp) #ifdef AFS_DARWIN_ENV tvc->v.v_ubcinfo = UBC_INFO_NULL; lockinit(&tvc->rwlock, PINOD, "vcache rwlock", 0, 0); - cache_purge(AFSTOV(tvc)); + cache_purge(AFSTOV(tvc)); tvc->v.v_data=tvc; tvc->v.v_tag=VT_AFS; /* VLISTNONE(&tvc->v); */ tvc->v.v_freelist.tqe_next=0; tvc->v.v_freelist.tqe_prev=(struct vnode **)0xdeadb; /*tvc->vrefCount++;*/ -#endif +#endif #ifdef AFS_FBSD_ENV lockinit(&tvc->rwlock, PINOD, "vcache rwlock", 0, 0); - cache_purge(AFSTOV(tvc)); + cache_purge(AFSTOV(tvc)); tvc->v.v_data=tvc; tvc->v.v_tag=VT_AFS; tvc->v.v_usecount++; /* steal an extra ref for now so vfree never happens */ @@ -965,9 +972,9 @@ struct vcache *afs_NewVCache(struct VenusFid *afid, struct server *serverp) /* * The proper value for mvstat (for root fids) is setup by the caller. */ - tvc->mvstat = 0; + tvc->mvstat = 0; if (afid->Fid.Vnode == 1 && afid->Fid.Unique == 1) - tvc->mvstat = 2; + tvc->mvstat = 2; if (afs_globalVFS == 0) osi_Panic("afs globalvfs"); vSetVfsp(tvc, afs_globalVFS); vSetType(tvc, VREG); @@ -1143,9 +1150,9 @@ void afs_FlushActiveVcaches(register afs_int32 doflocks) * this code. Also, drop the afs_xvcache lock while * getting vcache locks. */ - osi_vnhold(tvc,0); + osi_vnhold(tvc, 0); ReleaseReadLock(&afs_xvcache); -#if defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) +#if defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) afs_BozonLock(&tvc->pvnLock, tvc); #endif #if defined(AFS_SGI_ENV) @@ -1167,7 +1174,7 @@ void afs_FlushActiveVcaches(register afs_int32 doflocks) ICL_TYPE_INT32, tvc->execsOrWriters); code = afs_StoreOnLastReference(tvc, &ureq); ReleaseWriteLock(&tvc->lock); -#if defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) +#if defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) afs_BozonUnlock(&tvc->pvnLock, tvc); #endif hzero(tvc->flushDV); @@ -1179,10 +1186,10 @@ void afs_FlushActiveVcaches(register afs_int32 doflocks) } } else if (tvc->states & CUnlinkedDel) { /* - * Ignore errors + * Ignore errors */ ReleaseWriteLock(&tvc->lock); -#if defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) +#if defined(AFS_SUN_ENV) || defined(AFS_ALPHA_ENV) afs_BozonUnlock(&tvc->pvnLock, tvc); #endif #if defined(AFS_SGI_ENV) @@ -1214,7 +1221,7 @@ void afs_FlushActiveVcaches(register afs_int32 doflocks) /* Matches write code setting CCore flag */ crfree(cred); } - } + } #ifdef AFS_DARWIN_ENV if (VREFCOUNT(tvc) == 1 && UBCINFOEXISTS(&tvc->v)) { if (tvc->opens) panic("flushactive open, hasubc, but refcnt 1"); @@ -1232,12 +1239,12 @@ void afs_FlushActiveVcaches(register afs_int32 doflocks) * * Description: * Make sure a cache entry is up-to-date status-wise. - * + * * NOTE: everywhere that calls this can potentially be sped up * by checking CStatd first, and avoiding doing the InitReq * if this is up-to-date. * - * Anymore, the only places that call this KNOW already that the + * Anymore, the only places that call this KNOW already that the * vcache is not up-to-date, so we don't screw around. * * Parameters: @@ -1267,21 +1274,21 @@ int afs_VerifyVCache2(struct vcache *avc, struct vrequest *areq) return 0; } ObtainWriteLock(&afs_xcbhash, 461); - avc->states &= ~( CStatd | CUnique ); + avc->states &= ~( CStatd | CUnique ); avc->callback = NULL; afs_DequeueCallback(avc); ReleaseWriteLock(&afs_xcbhash); 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 + /* 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->states & CForeign) || (avc->fid.Fid.Vnode & 1)) + if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1)) osi_dnlc_purgedp (avc); else osi_dnlc_purgevp (avc); - + /* fetch the status info */ tvc = afs_GetVCache(&avc->fid, areq, NULL, avc); if (!tvc) return ENOENT; @@ -1307,7 +1314,7 @@ int afs_VerifyVCache2(struct vcache *avc, struct vrequest *areq) * * Callers: as of 1992-04-29, only called by WriteVCache */ -static void afs_SimpleVStat(register struct vcache *avc, +static void afs_SimpleVStat(register struct vcache *avc, register struct AFSFetchStatus *astat, struct vrequest *areq) { afs_size_t length; @@ -1331,7 +1338,7 @@ static void afs_SimpleVStat(register struct vcache *avc, (OSI_GET_LOCKID() == avc->vc_rwlockid)); if (length < avc->m.Length) { vnode_t *vp = (vnode_t *)avc; - + osi_Assert(WriteLocked(&avc->lock)); ReleaseWriteLock(&avc->lock); AFS_GUNLOCK(); @@ -1368,19 +1375,19 @@ static void afs_SimpleVStat(register struct vcache *avc, struct axscache *ac; avc->anyAccess = astat->AnonymousAccess; #ifdef badidea - if ((astat->CallerAccess & ~astat->AnonymousAccess)) - /* USED TO SAY : + if ((astat->CallerAccess & ~astat->AnonymousAccess)) + /* USED TO SAY : * Caller has at least one bit not covered by anonymous, and * thus may have interesting rights. * * HOWEVER, this is a really bad idea, because any access query * for bits which aren't covered by anonymous, on behalf of a user - * who doesn't have any special rights, will result in an answer of + * who doesn't have any special rights, will result in an answer of * the form "I don't know, lets make a FetchStatus RPC and find out!" * It's an especially bad idea under Ultrix, since (due to the lack of - * a proper access() call) it must perform several afs_access() calls + * a proper access() call) it must perform several afs_access() calls * in order to create magic mode bits that vary according to who makes - * the call. In other words, _every_ stat() generates a test for + * the call. In other words, _every_ stat() generates a test for * writeability... */ #endif /* badidea */ @@ -1410,7 +1417,7 @@ static void afs_SimpleVStat(register struct vcache *avc, * Must be called with a shared lock held on the vnode. */ -int afs_WriteVCache(register struct vcache *avc, +int afs_WriteVCache(register struct vcache *avc, register struct AFSStoreStatus *astatus, struct vrequest *areq) { afs_int32 code; @@ -1457,7 +1464,7 @@ int afs_WriteVCache(register struct vcache *avc, afs_DequeueCallback(avc); avc->states &= ~( CStatd | CUnique); /* turn off stat valid flag */ ReleaseWriteLock(&afs_xcbhash); - if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1)) + if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1)) osi_dnlc_purgedp (avc); /* if it (could be) a directory */ } ConvertWToSLock(&avc->lock); @@ -1483,7 +1490,7 @@ int afs_WriteVCache(register struct vcache *avc, * been modified. This is less than ideal. I haven't thought about * it sufficiently to be certain that it is adequate. */ -void afs_ProcessFS(register struct vcache *avc, register struct AFSFetchStatus *astat, +void afs_ProcessFS(register struct vcache *avc, register struct AFSFetchStatus *astat, struct vrequest *areq) { afs_size_t length; @@ -1543,19 +1550,19 @@ void afs_ProcessFS(register struct vcache *avc, register struct AFSFetchStatus * } avc->anyAccess = astat->AnonymousAccess; #ifdef badidea - if ((astat->CallerAccess & ~astat->AnonymousAccess)) - /* USED TO SAY : + if ((astat->CallerAccess & ~astat->AnonymousAccess)) + /* USED TO SAY : * Caller has at least one bit not covered by anonymous, and * thus may have interesting rights. * * HOWEVER, this is a really bad idea, because any access query * for bits which aren't covered by anonymous, on behalf of a user - * who doesn't have any special rights, will result in an answer of + * who doesn't have any special rights, will result in an answer of * the form "I don't know, lets make a FetchStatus RPC and find out!" * It's an especially bad idea under Ultrix, since (due to the lack of - * a proper access() call) it must perform several afs_access() calls + * a proper access() call) it must perform several afs_access() calls * in order to create magic mode bits that vary according to who makes - * the call. In other words, _every_ stat() generates a test for + * the call. In other words, _every_ stat() generates a test for * writeability... */ #endif /* badidea */ @@ -1577,8 +1584,8 @@ void afs_ProcessFS(register struct vcache *avc, register struct AFSFetchStatus * } /*afs_ProcessFS*/ -int afs_RemoteLookup(register struct VenusFid *afid, struct vrequest *areq, - char *name, struct VenusFid *nfid, struct AFSFetchStatus *OutStatusp, +int afs_RemoteLookup(register struct VenusFid *afid, struct vrequest *areq, + char *name, struct VenusFid *nfid, struct AFSFetchStatus *OutStatusp, struct AFSCallBack *CallBackp, struct server **serverp, struct AFSVolSync *tsyncp) { afs_int32 code; @@ -1596,11 +1603,11 @@ int afs_RemoteLookup(register struct VenusFid *afid, struct vrequest *areq, XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_XLOOKUP); RX_AFS_GUNLOCK(); code = RXAFS_Lookup(tc->id, (struct AFSFid *) &afid->Fid, name, - (struct AFSFid *) &nfid->Fid, + (struct AFSFid *) &nfid->Fid, OutStatusp, &OutDirStatus, CallBackp, tsyncp); RX_AFS_GLOCK(); XSTATS_END_TIME; - } else + } else code = -1; } while (afs_Analyze(tc, code, afid, areq, @@ -1622,7 +1629,7 @@ int afs_RemoteLookup(register struct VenusFid *afid, struct vrequest *areq, * afid : File ID. * areq : Ptr to associated vrequest structure, specifying the * user whose authentication tokens will be used. - * avc : caller may already have a vcache for this file, which is + * avc : caller may already have a vcache for this file, which is * already held. * * Environment: @@ -1636,7 +1643,7 @@ int afs_RemoteLookup(register struct VenusFid *afid, struct vrequest *areq, * * 1. Lock all files first, then directories. * 2. Within a particular type, lock entries in Fid.Vnode order. - * + * * This locking hierarchy is convenient because it allows locking * of a parent dir cache entry, given a file (to check its access * control list). It also allows renames to be handled easily by @@ -1646,7 +1653,7 @@ int afs_RemoteLookup(register struct VenusFid *afid, struct vrequest *areq, /* might have a vcache structure already, which must * already be held by the caller */ -struct vcache *afs_GetVCache(register struct VenusFid *afid, struct vrequest *areq, +struct vcache *afs_GetVCache(register struct VenusFid *afid, struct vrequest *areq, afs_int32 *cached, struct vcache *avc) { @@ -1663,7 +1670,7 @@ struct vcache *afs_GetVCache(register struct VenusFid *afid, struct vrequest *ar loop: #endif - ObtainSharedLock(&afs_xvcache,5); + ObtainSharedLock(&afs_xvcache,5); tvc = afs_FindVCache(afid, &retry, DO_STATS | DO_VLRU ); if (tvc && retry) { @@ -1673,16 +1680,16 @@ loop: goto loop; #endif } - + if (tvc) { - if (cached) + if (cached) *cached = 1; - if (tvc->states & CStatd) { + if (tvc->states & CStatd) { ReleaseSharedLock(&afs_xvcache); return tvc; } } - else { + else { UpgradeSToWLock(&afs_xvcache,21); /* no cache entry, better grab one */ @@ -1716,7 +1723,7 @@ loop: #endif /* AFS_OSF_ENV */ ObtainWriteLock(&afs_xcbhash, 464); - tvc->states &= ~CUnique; + tvc->states &= ~CUnique; tvc->callback = 0; afs_DequeueCallback(tvc); ReleaseWriteLock(&afs_xcbhash); @@ -1727,7 +1734,7 @@ loop: if (tvp) { if ((tvp->states & VForeign)) { if (newvcache) tvc->states |= CForeign; - if (newvcache && (tvp->rootVnode == afid->Fid.Vnode) + if (newvcache && (tvp->rootVnode == afid->Fid.Vnode) && (tvp->rootUnique == afid->Fid.Unique)) { tvc->mvstat = 2; } @@ -1814,8 +1821,8 @@ struct vcache *afs_LookupVCache(struct VenusFid *afid, struct vrequest *areq, } ReleaseReadLock(&tvc->lock); return tvc; - } - tvc->states &= ~CUnique; + } + tvc->states &= ~CUnique; ReleaseReadLock(&tvc->lock); ObtainReadLock(&afs_xvcache); @@ -1829,7 +1836,7 @@ struct vcache *afs_LookupVCache(struct VenusFid *afid, struct vrequest *areq, now = osi_Time(); origCBs = afs_allCBs; /* if anything changes, we don't have a cb */ code = afs_RemoteLookup(&adp->fid, areq, aname, &nfid, &OutStatus, &CallBack, - &serverp, &tsync); + &serverp, &tsync); #if defined(AFS_SGI_ENV) && !defined(AFS_SGI53_ENV) loop2: @@ -1855,7 +1862,7 @@ struct vcache *afs_LookupVCache(struct VenusFid *afid, struct vrequest *areq, ReleaseSharedLock(&afs_xvcache); ObtainWriteLock(&tvc->lock,55); - + /* It is always appropriate to throw away all the access rights? */ afs_FreeAllAxs(&(tvc->Access)); tvp = afs_GetVolume(afid, areq, READ_LOCK); /* copy useful per-vol info */ @@ -1882,7 +1889,7 @@ struct vcache *afs_LookupVCache(struct VenusFid *afid, struct vrequest *areq, afs_DequeueCallback(tvc); tvc->states &= ~( CStatd | CUnique ); ReleaseWriteLock(&afs_xcbhash); - if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) + if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) osi_dnlc_purgedp (tvc); /* if it (could be) a directory */ if ( tvp ) afs_PutVolume(tvp, READ_LOCK); @@ -1906,22 +1913,22 @@ struct vcache *afs_LookupVCache(struct VenusFid *afid, struct vrequest *areq, tvc->cbExpires = 3600+osi_Time(); /*XXX*/ tvc->states |= CStatd | CUnique; tvc->states &= ~CBulkFetching; - afs_QueueCallback(tvc, CBHash(3600), tvp); + afs_QueueCallback(tvc, CBHash(3600), tvp); } else { tvc->callback = NULL; afs_DequeueCallback(tvc); - tvc->states &= ~(CStatd | CUnique); - if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) + tvc->states &= ~(CStatd | CUnique); + if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) osi_dnlc_purgedp (tvc); /* if it (could be) a directory */ } } else { afs_DequeueCallback(tvc); - tvc->states &= ~CStatd; - tvc->states &= ~CUnique; + tvc->states &= ~CStatd; + tvc->states &= ~CUnique; tvc->callback = NULL; - if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) + if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) osi_dnlc_purgedp (tvc); /* if it (could be) a directory */ - } + } ReleaseWriteLock(&afs_xcbhash); if ( tvp ) afs_PutVolume(tvp, READ_LOCK); @@ -1956,7 +1963,7 @@ struct vcache *afs_GetRootVCache(struct VenusFid *afid, tfid = *afid; tfid.Fid.Vnode = 0; /* Means get rootfid of volume */ origCBs = afs_allCBs; /* ignore InitCallBackState */ - code = afs_RemoteLookup(&tfid, areq, NULL, &nfid, + code = afs_RemoteLookup(&tfid, areq, NULL, &nfid, &OutStatus, &CallBack, &serverp, &tsync); if (code) { return NULL; @@ -1965,21 +1972,21 @@ struct vcache *afs_GetRootVCache(struct VenusFid *afid, ObtainWriteLock(&tvolp->lock,56); tvolp->rootVnode = afid->Fid.Vnode = nfid.Fid.Vnode; tvolp->rootUnique = afid->Fid.Unique = nfid.Fid.Unique; - ReleaseWriteLock(&tvolp->lock); + ReleaseWriteLock(&tvolp->lock); /* ObtainReadLock(&tvolp->lock);*/ haveStatus = 1; } else { afid->Fid.Vnode = tvolp->rootVnode; afid->Fid.Unique = tvolp->rootUnique; - } - + } + ObtainSharedLock(&afs_xvcache,7); i = VCHash(afid); for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) { if (!FidCmp(&(tvc->fid), afid)) { #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 + /* 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 */ int vg; @@ -2018,7 +2025,7 @@ struct vcache *afs_GetRootVCache(struct VenusFid *afid, #ifdef AFS_OSF_ENV /* we already bumped the ref count in the for loop above */ #else /* AFS_OSF_ENV */ - osi_vnhold(tvc,0); + osi_vnhold(tvc, 0); #endif UpgradeSToWLock(&afs_xvcache,24); if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) { @@ -2048,10 +2055,10 @@ struct vcache *afs_GetRootVCache(struct VenusFid *afid, if (tvc->states & CStatd) { return tvc; - } else { + } else { ObtainReadLock(&tvc->lock); - tvc->states &= ~CUnique; + tvc->states &= ~CUnique; tvc->callback = NULL; /* redundant, perhaps */ ReleaseReadLock(&tvc->lock); } @@ -2065,7 +2072,7 @@ struct vcache *afs_GetRootVCache(struct VenusFid *afid, if (tvolp->states & VRO) tvc->states |= CRO; if (tvolp->states & VBackup) tvc->states |= CBackup; /* now copy ".." entry back out of volume structure, if necessary */ - if (newvcache && (tvolp->rootVnode == afid->Fid.Vnode) + if (newvcache && (tvolp->rootVnode == afid->Fid.Vnode) && (tvolp->rootUnique == afid->Fid.Unique)) { tvc->mvstat = 2; } @@ -2092,9 +2099,9 @@ struct vcache *afs_GetRootVCache(struct VenusFid *afid, ObtainWriteLock(&afs_xcbhash, 467); afs_DequeueCallback(tvc); tvc->callback = NULL; - tvc->states &= ~(CStatd|CUnique); + tvc->states &= ~(CStatd|CUnique); ReleaseWriteLock(&afs_xcbhash); - if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) + if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) osi_dnlc_purgedp (tvc); /* if it (could be) a directory */ ReleaseWriteLock(&tvc->lock); ObtainReadLock(&afs_xvcache); @@ -2102,12 +2109,12 @@ struct vcache *afs_GetRootVCache(struct VenusFid *afid, ReleaseReadLock(&afs_xvcache); return NULL; } - + ObtainWriteLock(&afs_xcbhash, 468); if (origCBs == afs_allCBs) { tvc->states |= CTruth; tvc->callback = serverp; - if (CallBack.ExpirationTime != 0) { + if (CallBack.ExpirationTime != 0) { tvc->cbExpires = CallBack.ExpirationTime+start; tvc->states |= CStatd; tvc->states &= ~CBulkFetching; @@ -2123,12 +2130,12 @@ struct vcache *afs_GetRootVCache(struct VenusFid *afid, afs_DequeueCallback(tvc); tvc->callback = NULL; tvc->states &= ~(CStatd | CUnique); - if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) + if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) osi_dnlc_purgedp (tvc); /* if it (could be) a directory */ } ReleaseWriteLock(&afs_xcbhash); afs_ProcessFS(tvc, &OutStatus, areq); - + ReleaseWriteLock(&tvc->lock); return tvc; } @@ -2136,8 +2143,8 @@ struct vcache *afs_GetRootVCache(struct VenusFid *afid, /* - * must be called with avc write-locked - * don't absolutely have to invalidate the hint unless the dv has + * must be called with avc write-locked + * don't absolutely have to invalidate the hint unless the dv has * changed, but be sure to get it right else there will be consistency bugs. */ afs_int32 afs_FetchStatus(struct vcache *avc, struct VenusFid *afid, @@ -2179,13 +2186,13 @@ if (!code) { ObtainWriteLock(&afs_xcbhash, 469); avc->states |= CTruth; if (avc->callback /* check for race */) { - if (CallBack.ExpirationTime != 0) { + if (CallBack.ExpirationTime != 0) { avc->cbExpires = CallBack.ExpirationTime+start; avc->states |= CStatd; avc->states &= ~CBulkFetching; afs_QueueCallback(avc, CBHash(CallBack.ExpirationTime), volp); } - else if (avc->states & CRO) + else if (avc->states & CRO) { /* ordinary callback on a read-only volume -- AFS 3.2 style */ avc->cbExpires = 3600+start; avc->states |= CStatd; @@ -2195,26 +2202,26 @@ if (!code) { else { afs_DequeueCallback(avc); avc->callback = NULL; - avc->states &= ~(CStatd|CUnique); - if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1)) + avc->states &= ~(CStatd|CUnique); + if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1)) osi_dnlc_purgedp (avc); /* if it (could be) a directory */ } } else { afs_DequeueCallback(avc); avc->callback = NULL; - avc->states &= ~(CStatd|CUnique); - if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1)) + avc->states &= ~(CStatd|CUnique); + if ((avc->states & CForeign) || (avc->fid.Fid.Vnode & 1)) osi_dnlc_purgedp (avc); /* if it (could be) a directory */ } ReleaseWriteLock(&afs_xcbhash); if ( volp ) afs_PutVolume(volp, READ_LOCK); } -else { /* used to undo the local callback, but that's too extreme. - * There are plenty of good reasons that fetchstatus might return - * an error, such as EPERM. If we have the vnode cached, statd, - * with callback, might as well keep track of the fact that we +else { /* used to undo the local callback, but that's too extreme. + * There are plenty of good reasons that fetchstatus might return + * an error, such as EPERM. If we have the vnode cached, statd, + * with callback, might as well keep track of the fact that we * don't have access... */ if (code == EPERM || code == EACCES) { @@ -2245,8 +2252,8 @@ return code; * Environment: * Nothing interesting. */ -void afs_StuffVcache(register struct VenusFid *afid, - struct AFSFetchStatus *OutStatus, struct AFSCallBack *CallBack, +void afs_StuffVcache(register struct VenusFid *afid, + struct AFSFetchStatus *OutStatus, struct AFSCallBack *CallBack, register struct conn *tc, struct vrequest *areq) { register afs_int32 code, i, newvcache=0; @@ -2285,7 +2292,7 @@ void afs_StuffVcache(register struct VenusFid *afid, ObtainWriteLock(&tvc->lock,58); tvc->states &= ~CStatd; - if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) + if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) osi_dnlc_purgedp (tvc); /* if it (could be) a directory */ /* Is it always appropriate to throw away all the access rights? */ @@ -2312,18 +2319,18 @@ void afs_StuffVcache(register struct VenusFid *afid, afs_ProcessFS(tvc, OutStatus, areq); tvc->callback = tc->srvr->server; - /* we use osi_Time twice below. Ideally, we would use the time at which + /* we use osi_Time twice below. Ideally, we would use the time at which * the FetchStatus call began, instead, but we don't have it here. So we - * make do with "now". In the CRO case, it doesn't really matter. In - * the other case, we hope that the difference between "now" and when the + * make do with "now". In the CRO case, it doesn't really matter. In + * the other case, we hope that the difference between "now" and when the * call actually began execution on the server won't be larger than the - * padding which the server keeps. Subtract 1 second anyway, to be on + * padding which the server keeps. Subtract 1 second anyway, to be on * the safe side. Can't subtract more because we don't know how big * ExpirationTime is. Possible consistency problems may arise if the call * timeout period becomes longer than the server's expiration padding. */ ObtainWriteLock(&afs_xcbhash, 470); if (CallBack->ExpirationTime != 0) { - tvc->cbExpires = CallBack->ExpirationTime+osi_Time()-1; + tvc->cbExpires = CallBack->ExpirationTime+osi_Time()-1; tvc->states |= CStatd; tvc->states &= ~CBulkFetching; afs_QueueCallback(tvc, CBHash(CallBack->ExpirationTime), tvp); @@ -2333,19 +2340,19 @@ void afs_StuffVcache(register struct VenusFid *afid, tvc->cbExpires = 3600+osi_Time(); /*XXX*/ tvc->states |= CStatd; tvc->states &= ~CBulkFetching; - afs_QueueCallback(tvc, CBHash(3600), tvp); + afs_QueueCallback(tvc, CBHash(3600), tvp); } else { afs_DequeueCallback(tvc); tvc->callback = NULL; - tvc->states &= ~(CStatd|CUnique); - if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) + tvc->states &= ~(CStatd|CUnique); + if ((tvc->states & CForeign) || (tvc->fid.Fid.Vnode & 1)) osi_dnlc_purgedp (tvc); /* if it (could be) a directory */ } ReleaseWriteLock(&afs_xcbhash); if ( tvp ) afs_PutVolume(tvp, READ_LOCK); - + /* look in per-pag cache */ if (tvc->Access && (ac = afs_FindAxs(tvc->Access, areq->uid))) ac->axess = OutStatus->CallerAccess; /* substitute pags */ @@ -2394,7 +2401,7 @@ void afs_PutVCache(register struct vcache *avc) * * Parameters: * afid : Pointer to the fid whose cache entry we desire. - * retry: (SGI-specific) tell the caller to drop the lock on xvcache, + * retry: (SGI-specific) tell the caller to drop the lock on xvcache, * unlock the vnode, and try again. * flags: bit 1 to specify whether to compute hit statistics. Not * set if FindVCache is called as part of internal bookkeeping. @@ -2424,7 +2431,7 @@ struct vcache *afs_FindVCache(struct VenusFid *afid, afs_int32 *retry, afs_int32 AFS_GLOCK(); if (vg) continue; -#endif /* AFS_OSF_ENV */ +#endif /* AFS_OSF_ENV */ break; } } @@ -2433,47 +2440,49 @@ struct vcache *afs_FindVCache(struct VenusFid *afid, afs_int32 *retry, afs_int32 if (tvc) { if (retry) *retry = 0; #if !defined(AFS_OSF_ENV) - osi_vnhold(tvc, retry); /* already held, above */ - if (retry && *retry) - return 0; + osi_vnhold(tvc, retry); /* already held, above */ + if (retry && *retry) + return 0; #endif /* * only move to front of vlru if we have proper vcache locking) */ if (flag & DO_VLRU) { - if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) { - refpanic ("FindVC VLRU inconsistent1"); - } - if (tvc->vlruq.next->prev != &(tvc->vlruq)) { - refpanic ("FindVC VLRU inconsistent1"); - } - if (tvc->vlruq.prev->next != &(tvc->vlruq)) { - refpanic ("FindVC VLRU inconsistent2"); - } + if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) { + refpanic ("FindVC VLRU inconsistent1"); + } + if (tvc->vlruq.next->prev != &(tvc->vlruq)) { + refpanic ("FindVC VLRU inconsistent1"); + } + if (tvc->vlruq.prev->next != &(tvc->vlruq)) { + refpanic ("FindVC VLRU inconsistent2"); + } UpgradeSToWLock(&afs_xvcache,26); QRemove(&tvc->vlruq); QAdd(&VLRU, &tvc->vlruq); ConvertWToSLock(&afs_xvcache); - if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) { - refpanic ("FindVC VLRU inconsistent1"); - } - if (tvc->vlruq.next->prev != &(tvc->vlruq)) { - refpanic ("FindVC VLRU inconsistent2"); - } - if (tvc->vlruq.prev->next != &(tvc->vlruq)) { - refpanic ("FindVC VLRU inconsistent3"); - } + if ((VLRU.next->prev != &VLRU) || (VLRU.prev->next != &VLRU)) { + refpanic ("FindVC VLRU inconsistent1"); + } + if (tvc->vlruq.next->prev != &(tvc->vlruq)) { + refpanic ("FindVC VLRU inconsistent2"); + } + if (tvc->vlruq.prev->next != &(tvc->vlruq)) { + refpanic ("FindVC VLRU inconsistent3"); + } } vcachegen++; - } + } if (flag & DO_STATS) { - if (tvc) afs_stats_cmperf.vcacheHits++; - else afs_stats_cmperf.vcacheMisses++; - if (afs_IsPrimaryCellNum(afid->Cell)) - afs_stats_cmperf.vlocalAccesses++; - else - afs_stats_cmperf.vremoteAccesses++; + if (tvc) + afs_stats_cmperf.vcacheHits++; + else + afs_stats_cmperf.vcacheMisses++; + if (afs_IsPrimaryCellNum(afid->Cell)) + afs_stats_cmperf.vlocalAccesses++; + else + afs_stats_cmperf.vremoteAccesses++; } #ifdef AFS_LINUX22_ENV @@ -2497,7 +2506,7 @@ struct vcache *afs_FindVCache(struct VenusFid *afid, afs_int32 *retry, afs_int32 * Parameters: * avcp : Fill in pointer if we found one and only one. * afid : Pointer to the fid whose cache entry we desire. - * retry: (SGI-specific) tell the caller to drop the lock on xvcache, + * retry: (SGI-specific) tell the caller to drop the lock on xvcache, * unlock the vnode, and try again. * flags: bit 1 to specify whether to compute hit statistics. Not * set if FindVCache is called as part of internal bookkeeping. @@ -2526,7 +2535,7 @@ afs_int32 afs_NFSFindVCache(struct vcache **avcp, struct VenusFid *afid) loop: #endif - ObtainSharedLock(&afs_xvcache,331); + ObtainSharedLock(&afs_xvcache,331); i = VCHash(afid); for(tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) { @@ -2567,7 +2576,7 @@ afs_int32 afs_NFSFindVCache(struct vcache **avcp, struct VenusFid *afid) if (tvc) { #if defined(AFS_SGI_ENV) && !defined(AFS_SGI53_ENV) afs_int32 retry = 0; - osi_vnhold(tvc, &retry); + osi_vnhold(tvc, &retry); if (retry) { count = 0; found_tvc = (struct vcache*)0; @@ -2639,8 +2648,8 @@ void afs_vcacheInit(int astatSize) #if 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 + afs_maxvcount = nvnode/2; /* limit ourselves to half the total */ +#endif if (astatSize < afs_maxvcount) { afs_maxvcount = astatSize; } @@ -2661,10 +2670,10 @@ void afs_vcacheInit(int astatSize) freeVCList = &(tvp[0]); for(i=0; i < astatSize-1; i++) { tvp[i].nextfree = &(tvp[i+1]); - } + } tvp[astatSize-1].nextfree = NULL; #ifdef KERNEL_HAVE_PIN - pin((char *)tvp, astatSize * sizeof(struct vcache)); /* XXX */ + pin((char *)tvp, astatSize * sizeof(struct vcache)); /* XXX */ #endif #endif @@ -2729,8 +2738,8 @@ void shutdown_vcache(void) tvc->linkData = 0; } } - /* - * Also free the remaining ones in the Cache + /* + * Also free the remaining ones in the Cache */ for (i=0; i < VCSIZE; i++) { for (tvc = afs_vhashT[i]; tvc; tvc = tvc->hnext) { -- 2.39.5