void osi_PostPopulateVCache(struct vcache *avc) { memset(&(avc->vc_bhv_desc), 0, sizeof(avc->vc_bhv_desc)); bhv_desc_init(&(avc->vc_bhv_desc), avc, avc, &Afs_vnodeops); #if defined(AFS_SGI65_ENV) vn_bhv_head_init(&(avc->v.v_bh), "afsvp"); vn_bhv_insert_initial(&(avc->v.v_bh), &(avc->vc_bhv_desc)); avc->v.v_mreg = avc->v.v_mregb = (struct pregion *)avc; # if defined(VNODE_TRACING) avc->v.v_trace = ktrace_alloc(VNODE_TRACE_SIZE, 0); # endif init_bitlock(&avc->v.v_pcacheflag, VNODE_PCACHE_LOCKBIT, "afs_pcache", avc->v.v_number); init_mutex(&avc->v.v_filocksem, MUTEX_DEFAULT, "afsvfl", (long)avc); init_mutex(&avc->v.v_buf_lock, MUTEX_DEFAULT, "afsvnbuf", (long)avc); #else bhv_head_init(&(avc->v.v_bh)); bhv_insert_initial(&(avc->v.v_bh), &(avc->vc_bhv_desc)); #endif vnode_pcache_init(&avc->v); #if defined(DEBUG) && defined(VNODE_INIT_BITLOCK) /* Above define is never true execpt in SGI test kernels. */ init_bitlock(&avc->v.v_flag, VLOCK, "vnode", avc->v.v_number); #endif #ifdef INTR_KTHREADS AFS_VN_INIT_BUF_LOCK(&(avc->v)); #endif vSetVfsp(avc, afs_globalVFS); vSetType(avc, VREG); VN_SET_DPAGES(&(avc->v), NULL); osi_Assert((avc->v.v_flag & VINACT) == 0); avc->v.v_flag = 0; osi_Assert(VN_GET_PGCNT(&(avc->v)) == 0); osi_Assert(avc->mapcnt == 0 && avc->vc_locktrips == 0); osi_Assert(avc->vc_rwlockid == OSI_NO_LOCKID); osi_Assert(avc->v.v_filocks == NULL); # if !defined(AFS_SGI65_ENV) osi_Assert(avc->v.v_filocksem == NULL); # endif osi_Assert(avc->cred == NULL); # if defined(AFS_SGI64_ENV) vnode_pcache_reinit(&avc->v); avc->v.v_rdev = NODEV; # endif vn_initlist((struct vnlist *)&avc->v); avc->lastr = 0; }
int idbg_afsvfslist() { struct vcache *tvc; register struct afs_q *tq; struct afs_q *uq; afs_int32 nodeid; /* what ls prints as 'inode' */ AFS_GLOCK(); for (tq = VLRU.prev; tq != &VLRU; tq = uq) { tvc = QTOV(tq); uq = QPrev(tq); nodeid = tvc->f.fid.Fid.Vnode + (tvc->f.fid.Fid.Volume << 16); nodeid &= 0x7fffffff; qprintf("avp 0x%x type %s cnt %d pg %d map %d nodeid %d(0x%x)\n", tvc, tab_vtypes[((vnode_t *) tvc)->v_type], ((vnode_t *) tvc)->v_count, (int)VN_GET_PGCNT((vnode_t *) tvc), (int)tvc->mapcnt, nodeid, nodeid); } AFS_GUNLOCK(); return 0; }
/* Try to discard pages, in order to recycle a vcache entry. * * We also make some sanity checks: ref count, open count, held locks. * * We also do some non-VM-related chores, such as releasing the cred pointer * (for AIX and Solaris) and releasing the gnode (for AIX). * * Locking: afs_xvcache lock is held. It must not be dropped. */ int osi_VM_FlushVCache(struct vcache *avc) { int s, code; vnode_t *vp = &avc->v; if (avc->vrefCount != 0) return EBUSY; if (avc->opens != 0) return EBUSY; /* * Just in case someone is still referring to the vnode we give up * trying to get rid of this guy. */ if (CheckLock(&avc->lock) || LockWaiters(&avc->lock)) return EBUSY; s = VN_LOCK(vp); /* * we just need to avoid the race * in vn_rele between the ref count going to 0 and VOP_INACTIVE * finishing up. * Note that although we checked vcount above, we didn't have the lock */ if (vp->v_count > 0 || (vp->v_flag & VINACT)) { VN_UNLOCK(vp, s); return EBUSY; } VN_UNLOCK(vp, s); /* * Since we store on last close and on VOP_INACTIVE * there should be NO dirty pages * Note that we hold the xvcache lock the entire time. */ AFS_GUNLOCK(); PTOSSVP(vp, (off_t) 0, (off_t) MAXLONG); AFS_GLOCK(); /* afs_chkpgoob will drop and re-acquire the global lock. */ afs_chkpgoob(vp, 0); osi_Assert(!VN_GET_PGCNT(vp)); osi_Assert(!AFS_VN_MAPPED(vp)); osi_Assert(!AFS_VN_DIRTY(&avc->v)); #if defined(AFS_SGI65_ENV) if (vp->v_filocks) cleanlocks(vp, IGN_PID, 0); mutex_destroy(&vp->v_filocksem); #else /* AFS_SGI65_ENV */ if (vp->v_filocksem) { if (vp->v_filocks) #ifdef AFS_SGI64_ENV cleanlocks(vp, &curprocp->p_flid); #else cleanlocks(vp, IGN_PID, 0); #endif osi_Assert(vp->v_filocks == NULL); mutex_destroy(vp->v_filocksem); kmem_free(vp->v_filocksem, sizeof *vp->v_filocksem); vp->v_filocksem = NULL; } #endif /* AFS_SGI65_ENV */ if (avc->vrefCount) osi_Panic("flushVcache: vm race"); #ifdef AFS_SGI64_ENV AFS_GUNLOCK(); vnode_pcache_reclaim(vp); /* this can sleep */ vnode_pcache_free(vp); if (vp->v_op != &Afs_vnodeops) { VOP_RECLAIM(vp, FSYNC_WAIT, code); } AFS_GLOCK(); #ifdef AFS_SGI65_ENV #ifdef VNODE_TRACING ktrace_free(vp->v_trace); #endif /* VNODE_TRACING */ vn_bhv_remove(VN_BHV_HEAD(vp), &(avc->vc_bhv_desc)); vn_bhv_head_destroy(&(vp->v_bh)); destroy_bitlock(&vp->v_pcacheflag); mutex_destroy(&vp->v_buf_lock); #else bhv_remove(VN_BHV_HEAD(vp), &(avc->vc_bhv_desc)); bhv_head_destroy(&(vp->v_bh)); #endif vp->v_flag = 0; /* debug */ #if defined(DEBUG) && defined(VNODE_INIT_BITLOCK) destroy_bitlock(&vp->v_flag); #endif #ifdef INTR_KTHREADS AFS_VN_DESTROY_BUF_LOCK(vp); #endif #endif /* AFS_SGI64_ENV */ return 0; }