#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/mount.h>
#include <sys/namei.h>
#include <sys/vnode.h>
#include <sys/malloc.h>
#include <nfs/rpcv2.h>
#include <nfs/nfsproto.h>
#include <nfs/nfs.h>
#include <nfs/nfsnode.h>
#include <nfs/nfsmount.h>
LIST_HEAD(nfsnodehashhead, nfsnode) *nfsnodehashtbl;
u_long nfsnodehash;
#define TRUE 1
#define FALSE 0
void
nfs_nhinit()
{
nfsnodehashtbl = hashinit(desiredvnodes, M_NFSNODE, &nfsnodehash);
}
u_long
nfs_hash(fhp, fhsize)
register nfsfh_t *fhp;
int fhsize;
{
register u_char *fhpp;
register u_long fhsum;
register int i;
fhpp = &fhp->fh_bytes[0];
fhsum = 0;
for (i = 0; i < fhsize; i++)
fhsum += *fhpp++;
return (fhsum);
}
int nfs_node_hash_lock;
int
nfs_nget(mntp, fhp, fhsize, npp)
struct mount *mntp;
register nfsfh_t *fhp;
int fhsize;
struct nfsnode **npp;
{
struct proc *p = current_proc();
struct nfsnode *np;
struct nfsnodehashhead *nhpp;
register struct vnode *vp;
struct vnode *nvp;
int error;
struct mount *mp;
if (!mntp || (mntp->mnt_kern_flag & MNTK_UNMOUNT)) {
*npp = 0;
return (!mntp ? ENXIO : EPERM);
}
nhpp = NFSNOHASH(nfs_hash(fhp, fhsize));
loop:
for (np = nhpp->lh_first; np != 0; np = np->n_hash.le_next) {
mp = (np->n_flag & NINIT) ? np->n_mount : NFSTOV(np)->v_mount;
if (mntp != mp || np->n_fhsize != fhsize ||
bcmp((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize))
continue;
if (np->n_flag & NINIT) {
np->n_flag |= NWINIT;
tsleep(np, PINOD, "nfsngt", 0);
goto loop;
}
vp = NFSTOV(np);
if (vget(vp, LK_EXCLUSIVE, p))
goto loop;
*npp = np;
return(0);
}
if (nfs_node_hash_lock) {
while (nfs_node_hash_lock) {
nfs_node_hash_lock = -1;
tsleep(&nfs_node_hash_lock, PVM, "nfsngt", 0);
}
goto loop;
}
nfs_node_hash_lock = 1;
MALLOC_ZONE(np, struct nfsnode *, sizeof *np, M_NFSNODE, M_WAITOK);
bzero((caddr_t)np, sizeof *np);
np->n_flag |= NINIT;
np->n_mount = mntp;
lockinit(&np->n_lock, PINOD, "nfsnode", 0, 0);
lockmgr(&np->n_lock, LK_EXCLUSIVE, NULL, p);
if (fhsize > NFS_SMALLFH) {
MALLOC_ZONE(np->n_fhp, nfsfh_t *,
fhsize, M_NFSBIGFH, M_WAITOK);
} else
np->n_fhp = &np->n_fh;
bcopy((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize);
np->n_fhsize = fhsize;
LIST_INSERT_HEAD(nhpp, np, n_hash);
np->n_flag |= NHASHED;
if (nfs_node_hash_lock < 0)
wakeup(&nfs_node_hash_lock);
nfs_node_hash_lock = 0;
error = getnewvnode(VT_NFS, mntp, nfsv2_vnodeop_p, &nvp);
if (error) {
LIST_REMOVE(np, n_hash);
np->n_flag &= ~NHASHED;
if (np->n_fhsize > NFS_SMALLFH)
FREE_ZONE((caddr_t)np->n_fhp, np->n_fhsize, M_NFSBIGFH);
FREE_ZONE(np, sizeof *np, M_NFSNODE);
*npp = 0;
return (error);
}
vp = nvp;
vp->v_data = np;
np->n_vnode = vp;
*npp = np;
np->n_flag &= ~NINIT;
if (np->n_flag & NWINIT) {
np->n_flag &= ~NWINIT;
wakeup((caddr_t)np);
}
return (error);
}
int
nfs_inactive(ap)
struct vop_inactive_args *ap;
{
register struct nfsnode *np;
register struct sillyrename *sp;
struct proc *p = current_proc();
extern int prtactive;
struct ucred *cred;
np = VTONFS(ap->a_vp);
if (prtactive && ap->a_vp->v_usecount != 0)
vprint("nfs_inactive: pushing active", ap->a_vp);
if (ap->a_vp->v_type != VDIR) {
sp = np->n_sillyrename;
np->n_sillyrename = (struct sillyrename *)0;
} else
sp = (struct sillyrename *)0;
if (sp) {
#if DIAGNOSTIC
kprintf("nfs_inactive removing %s, dvp=%x, a_vp=%x, ap=%x, np=%x, sp=%x\n", &sp->s_name[0], (unsigned)sp->s_dvp, (unsigned)ap->a_vp, (unsigned)ap, (unsigned)np, (unsigned)sp);
#endif
(void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, p, 1);
np->n_size = 0;
ubc_setsize(ap->a_vp, (off_t)0);
nfs_removeit(sp);
LIST_REMOVE(np, n_hash);
np->n_flag &= ~NHASHED;
cred = sp->s_cred;
if (cred != NOCRED) {
sp->s_cred = NOCRED;
crfree(cred);
}
vrele(sp->s_dvp);
FREE_ZONE((caddr_t)sp, sizeof (struct sillyrename), M_NFSREQ);
}
np->n_flag &= (NMODIFIED | NFLUSHINPROG | NFLUSHWANT | NQNFSEVICTED |
NQNFSNONCACHE | NQNFSWRITE | NHASHED);
VOP_UNLOCK(ap->a_vp, 0, ap->a_p);
return (0);
}
int
nfs_reclaim(ap)
struct vop_reclaim_args *ap;
{
register struct vnode *vp = ap->a_vp;
register struct nfsnode *np = VTONFS(vp);
register struct nfsmount *nmp = VFSTONFS(vp->v_mount);
register struct nfsdmap *dp, *dp2;
extern int prtactive;
if (prtactive && vp->v_usecount != 0)
vprint("nfs_reclaim: pushing active", vp);
if (np->n_flag & NHASHED) {
LIST_REMOVE(np, n_hash);
np->n_flag &= ~NHASHED;
}
cache_purge(vp);
if ((nmp->nm_flag & NFSMNT_NQNFS) && np->n_timer.cqe_next != 0) {
CIRCLEQ_REMOVE(&nmp->nm_timerhead, np, n_timer);
}
if (vp->v_type == VDIR) {
dp = np->n_cookies.lh_first;
while (dp) {
dp2 = dp;
dp = dp->ndm_list.le_next;
FREE_ZONE((caddr_t)dp2,
sizeof (struct nfsdmap), M_NFSDIROFF);
}
}
if (np->n_fhsize > NFS_SMALLFH) {
FREE_ZONE((caddr_t)np->n_fhp, np->n_fhsize, M_NFSBIGFH);
}
FREE_ZONE(vp->v_data, sizeof (struct nfsnode), M_NFSNODE);
vp->v_data = (void *)0;
return (0);
}
int
nfs_lock(ap)
struct vop_lock_args *ap;
{
register struct vnode *vp = ap->a_vp;
if (vp->v_tag == VT_NON)
return (ENOENT);
return(lockmgr(&VTONFS(vp)->n_lock, ap->a_flags, &vp->v_interlock,
ap->a_p));
}
int
nfs_unlock(ap)
struct vop_unlock_args *ap;
{
struct vnode *vp = ap->a_vp;
return (lockmgr(&VTONFS(vp)->n_lock, ap->a_flags | LK_RELEASE,
&vp->v_interlock, ap->a_p));
}
int
nfs_islocked(ap)
struct vop_islocked_args *ap;
{
return (lockstatus(&VTONFS(ap->a_vp)->n_lock));
}