#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/kauth.h>
#include <sys/mount_internal.h>
#include <sys/vnode.h>
#include <sys/ubc.h>
#include <sys/malloc.h>
#include <nfs/rpcv2.h>
#include <nfs/nfsproto.h>
#include <nfs/nfs.h>
#include <nfs/nfsnode.h>
#include <nfs/nfs_gss.h>
#include <nfs/nfsmount.h>
#define NFSNOHASH(fhsum) \
(&nfsnodehashtbl[(fhsum) & nfsnodehash])
static LIST_HEAD(nfsnodehashhead, nfsnode) *nfsnodehashtbl;
static u_long nfsnodehash;
static lck_grp_t *nfs_node_hash_lck_grp;
static lck_grp_t *nfs_node_lck_grp;
lck_mtx_t *nfs_node_hash_mutex;
void
nfs_nhinit(void)
{
nfs_node_hash_lck_grp = lck_grp_alloc_init("nfs_node_hash", LCK_GRP_ATTR_NULL);
nfs_node_hash_mutex = lck_mtx_alloc_init(nfs_node_hash_lck_grp, LCK_ATTR_NULL);
nfs_node_lck_grp = lck_grp_alloc_init("nfs_node", LCK_GRP_ATTR_NULL);
}
void
nfs_nhinit_finish(void)
{
lck_mtx_lock(nfs_node_hash_mutex);
if (!nfsnodehashtbl)
nfsnodehashtbl = hashinit(desiredvnodes, M_NFSNODE, &nfsnodehash);
lck_mtx_unlock(nfs_node_hash_mutex);
}
u_long
nfs_hash(u_char *fhp, int fhsize)
{
u_long fhsum;
int i;
fhsum = 0;
for (i = 0; i < fhsize; i++)
fhsum += *fhp++;
return (fhsum);
}
int
nfs_nget(
mount_t mp,
nfsnode_t dnp,
struct componentname *cnp,
u_char *fhp,
int fhsize,
struct nfs_vattr *nvap,
u_int64_t *xidp,
int flags,
nfsnode_t *npp)
{
nfsnode_t np;
struct nfsnodehashhead *nhpp;
vnode_t vp;
int error, nfsvers;
mount_t mp2;
struct vnode_fsparam vfsp;
uint32_t vid;
FSDBG_TOP(263, mp, dnp, flags, npp);
if (!mp || (mp->mnt_kern_flag & MNTK_FRCUNMOUNT)) {
*npp = NULL;
error = ENXIO;
FSDBG_BOT(263, mp, dnp, 0xd1e, error);
return (error);
}
nfsvers = VFSTONFS(mp)->nm_vers;
nhpp = NFSNOHASH(nfs_hash(fhp, fhsize));
loop:
lck_mtx_lock(nfs_node_hash_mutex);
for (np = nhpp->lh_first; np != 0; np = np->n_hash.le_next) {
mp2 = (np->n_hflag & NHINIT) ? np->n_mount : NFSTOMP(np);
if (mp != mp2 || np->n_fhsize != fhsize ||
bcmp(fhp, np->n_fhp, fhsize))
continue;
FSDBG(263, dnp, np, np->n_flag, 0xcace0000);
if (np->n_hflag & NHLOCKED) {
np->n_hflag |= NHLOCKWANT;
FSDBG(263, dnp, np, np->n_flag, 0xcace2222);
msleep(np, nfs_node_hash_mutex, PDROP | PINOD, "nfs_nget", NULL);
FSDBG(263, dnp, np, np->n_flag, 0xcace3333);
goto loop;
}
vp = NFSTOV(np);
vid = vnode_vid(vp);
lck_mtx_unlock(nfs_node_hash_mutex);
if ((error = vnode_getwithvid(vp, vid))) {
FSDBG_BOT(263, dnp, *npp, 0xcace0d1e, error);
return (error);
}
if ((error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE))) {
FSDBG(263, dnp, *npp, 0xcaced1e2, error);
vnode_put(vp);
goto loop;
}
error = nfs_loadattrcache(np, nvap, xidp, 0);
if (error) {
nfs_unlock(np);
vnode_put(vp);
} else {
if (dnp && cnp && (flags & NG_MAKEENTRY))
cache_enter(NFSTOV(dnp), vp, cnp);
*npp = np;
}
FSDBG_BOT(263, dnp, *npp, 0xcace0000, error);
return(error);
}
FSDBG(263, mp, dnp, npp, 0xaaaaaaaa);
MALLOC_ZONE(np, nfsnode_t, sizeof *np, M_NFSNODE, M_WAITOK);
if (!np) {
lck_mtx_unlock(nfs_node_hash_mutex);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000001, ENOMEM);
return (ENOMEM);
}
bzero(np, sizeof *np);
np->n_hflag |= (NHINIT | NHLOCKED);
np->n_mount = mp;
if (dnp && cnp && ((cnp->cn_namelen != 2) ||
(cnp->cn_nameptr[0] != '.') || (cnp->cn_nameptr[1] != '.'))) {
vnode_t dvp = NFSTOV(dnp);
if (!vnode_get(dvp)) {
if (!vnode_ref(dvp))
np->n_parent = dvp;
vnode_put(dvp);
}
}
if (fhsize > NFS_SMALLFH) {
MALLOC_ZONE(np->n_fhp, u_char *,
fhsize, M_NFSBIGFH, M_WAITOK);
if (!np->n_fhp) {
lck_mtx_unlock(nfs_node_hash_mutex);
FREE_ZONE(np, sizeof *np, M_NFSNODE);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000002, ENOMEM);
return (ENOMEM);
}
} else {
np->n_fhp = &np->n_fh[0];
}
bcopy(fhp, np->n_fhp, fhsize);
np->n_fhsize = fhsize;
LIST_INSERT_HEAD(nhpp, np, n_hash);
np->n_hflag |= NHHASHED;
FSDBG(266, 0, np, np->n_flag, np->n_hflag);
lck_rw_init(&np->n_lock, nfs_node_lck_grp, LCK_ATTR_NULL);
lck_rw_init(&np->n_datalock, nfs_node_lck_grp, LCK_ATTR_NULL);
nfs_lock(np, NFS_NODE_LOCK_FORCE);
lck_mtx_unlock(nfs_node_hash_mutex);
error = nfs_loadattrcache(np, nvap, xidp, 1);
if (error) {
FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
nfs_unlock(np);
lck_mtx_lock(nfs_node_hash_mutex);
LIST_REMOVE(np, n_hash);
np->n_hflag &= ~(NHHASHED|NHINIT|NHLOCKED);
if (np->n_hflag & NHLOCKWANT) {
np->n_hflag &= ~NHLOCKWANT;
wakeup(np);
}
lck_mtx_unlock(nfs_node_hash_mutex);
if (np->n_parent) {
if (!vnode_get(np->n_parent)) {
vnode_rele(np->n_parent);
vnode_put(np->n_parent);
}
np->n_parent = NULL;
}
lck_rw_destroy(&np->n_lock, nfs_node_lck_grp);
lck_rw_destroy(&np->n_datalock, nfs_node_lck_grp);
if (np->n_fhsize > NFS_SMALLFH)
FREE_ZONE(np->n_fhp, np->n_fhsize, M_NFSBIGFH);
FREE_ZONE(np, sizeof *np, M_NFSNODE);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000003, error);
return (error);
}
NFS_CHANGED_UPDATE(nfsvers, np, nvap);
if (nvap->nva_type == VDIR)
NFS_CHANGED_UPDATE_NC(nfsvers, np, nvap);
NMODEINVALIDATE(np);
vfsp.vnfs_mp = mp;
vfsp.vnfs_vtype = nvap->nva_type;
vfsp.vnfs_str = "nfs";
vfsp.vnfs_dvp = dnp ? NFSTOV(dnp) : NULL;
vfsp.vnfs_fsnode = np;
if (nfsvers == NFS_VER4) {
#if FIFO
if (nvap->nva_type == VFIFO)
vfsp.vnfs_vops = fifo_nfsv4nodeop_p;
else
#endif
if (nvap->nva_type == VBLK || nvap->nva_type == VCHR)
vfsp.vnfs_vops = spec_nfsv4nodeop_p;
else
vfsp.vnfs_vops = nfsv4_vnodeop_p;
} else {
#if FIFO
if (nvap->nva_type == VFIFO)
vfsp.vnfs_vops = fifo_nfsv2nodeop_p;
else
#endif
if (nvap->nva_type == VBLK || nvap->nva_type == VCHR)
vfsp.vnfs_vops = spec_nfsv2nodeop_p;
else
vfsp.vnfs_vops = nfsv2_vnodeop_p;
}
vfsp.vnfs_markroot = (flags & NG_MARKROOT) ? 1 : 0;
vfsp.vnfs_marksystem = 0;
vfsp.vnfs_rdev = 0;
vfsp.vnfs_filesize = nvap->nva_size;
vfsp.vnfs_cnp = cnp;
vfsp.vnfs_flags = VNFS_ADDFSREF;
if (!dnp || !cnp || !(flags & NG_MAKEENTRY))
vfsp.vnfs_flags |= VNFS_NOCACHE;
error = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &vfsp, &np->n_vnode);
if (error) {
FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
nfs_unlock(np);
lck_mtx_lock(nfs_node_hash_mutex);
LIST_REMOVE(np, n_hash);
np->n_hflag &= ~(NHHASHED|NHINIT|NHLOCKED);
if (np->n_hflag & NHLOCKWANT) {
np->n_hflag &= ~NHLOCKWANT;
wakeup(np);
}
lck_mtx_unlock(nfs_node_hash_mutex);
if (np->n_parent) {
if (!vnode_get(np->n_parent)) {
vnode_rele(np->n_parent);
vnode_put(np->n_parent);
}
np->n_parent = NULL;
}
lck_rw_destroy(&np->n_lock, nfs_node_lck_grp);
lck_rw_destroy(&np->n_datalock, nfs_node_lck_grp);
if (np->n_fhsize > NFS_SMALLFH)
FREE_ZONE(np->n_fhp, np->n_fhsize, M_NFSBIGFH);
FREE_ZONE(np, sizeof *np, M_NFSNODE);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000004, error);
return (error);
}
vp = np->n_vnode;
vnode_settag(vp, VT_NFS);
lck_mtx_lock(nfs_node_hash_mutex);
np->n_hflag &= ~(NHINIT|NHLOCKED);
if (np->n_hflag & NHLOCKWANT) {
np->n_hflag &= ~NHLOCKWANT;
wakeup(np);
}
lck_mtx_unlock(nfs_node_hash_mutex);
*npp = np;
FSDBG_BOT(263, dnp, vp, *npp, error);
return (error);
}
int
nfs_vnop_inactive(ap)
struct vnop_inactive_args *ap;
{
vnode_t vp;
nfsnode_t np;
struct nfs_sillyrename *nsp;
struct nfs_vattr nvattr;
int unhash, attrerr;
vp = ap->a_vp;
np = VTONFS(ap->a_vp);
nfs_lock(np, NFS_NODE_LOCK_FORCE);
if (vnode_vtype(vp) != VDIR) {
nsp = np->n_sillyrename;
np->n_sillyrename = NULL;
} else
nsp = NULL;
FSDBG_TOP(264, vp, np, np->n_flag, nsp);
if (!nsp) {
np->n_flag &= (NMODIFIED);
nfs_unlock(np);
FSDBG_BOT(264, vp, np, np->n_flag, 0);
return (0);
}
nfs_unlock(np);
nfs_vinvalbuf2(vp, V_SAVE, vfs_context_thread(ap->a_context), nsp->nsr_cred, 1);
cache_purge(vp);
attrerr = nfs_getattr(np, &nvattr, ap->a_context, 0);
if (vnode_isinuse(vp, 0) || (!attrerr && (nvattr.nva_nlink > 1))) {
unhash = 0;
} else {
unhash = 1;
ubc_setsize(vp, 0);
}
nfs_lock2(nsp->nsr_dnp, np, NFS_NODE_LOCK_FORCE);
lck_mtx_lock(nfs_node_hash_mutex);
while (np->n_hflag & NHLOCKED) {
np->n_hflag |= NHLOCKWANT;
msleep(np, nfs_node_hash_mutex, PINOD, "nfs_inactive", NULL);
}
np->n_hflag |= NHLOCKED;
lck_mtx_unlock(nfs_node_hash_mutex);
cache_purge(vp);
FSDBG(264, np, np->n_size, np->n_vattr.nva_size, 0xf00d00f1);
nfs_removeit(nsp);
np->n_flag &= (NMODIFIED);
nfs_unlock2(nsp->nsr_dnp, np);
if (unhash && vnode_isinuse(vp, 0)) {
unhash = 0;
ubc_setsize(vp, np->n_size);
}
lck_mtx_lock(nfs_node_hash_mutex);
if (unhash) {
if (np->n_hflag & NHHASHED) {
LIST_REMOVE(np, n_hash);
np->n_hflag &= ~NHHASHED;
FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
}
vnode_recycle(vp);
}
np->n_hflag &= ~NHLOCKED;
if (np->n_hflag & NHLOCKWANT) {
np->n_hflag &= ~NHLOCKWANT;
wakeup(np);
}
lck_mtx_unlock(nfs_node_hash_mutex);
if (nsp->nsr_cred != NOCRED)
kauth_cred_unref(&nsp->nsr_cred);
vnode_rele(NFSTOV(nsp->nsr_dnp));
FREE_ZONE(nsp, sizeof(*nsp), M_NFSREQ);
FSDBG_BOT(264, vp, np, np->n_flag, 0);
return (0);
}
int
nfs_vnop_reclaim(ap)
struct vnop_reclaim_args *ap;
{
vnode_t vp = ap->a_vp;
nfsnode_t np = VTONFS(vp);
struct nfsdmap *dp, *dp2;
FSDBG_TOP(265, vp, np, np->n_flag, 0);
lck_mtx_lock(nfs_node_hash_mutex);
if ((vnode_vtype(vp) != VDIR) && np->n_sillyrename)
printf("nfs_reclaim: leaving unlinked file %s\n", np->n_sillyrename->nsr_name);
vnode_removefsref(vp);
if (np->n_hflag & NHHASHED) {
LIST_REMOVE(np, n_hash);
np->n_hflag &= ~NHHASHED;
FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
}
lck_mtx_unlock(nfs_node_hash_mutex);
nfs_lock(np, NFS_NODE_LOCK_FORCE);
if (vnode_vtype(vp) == 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(np->n_fhp, np->n_fhsize, M_NFSBIGFH);
}
nfs_unlock(np);
vnode_clearfsnode(vp);
if (np->n_parent) {
if (!vnode_get(np->n_parent)) {
vnode_rele(np->n_parent);
vnode_put(np->n_parent);
}
np->n_parent = NULL;
}
lck_rw_destroy(&np->n_lock, nfs_node_lck_grp);
lck_rw_destroy(&np->n_datalock, nfs_node_lck_grp);
FSDBG_BOT(265, vp, np, np->n_flag, 0xd1ed1e);
FREE_ZONE(np, sizeof(struct nfsnode), M_NFSNODE);
return (0);
}
int
nfs_lock(nfsnode_t np, int locktype)
{
FSDBG_TOP(268, np, locktype, np->n_lockowner, 0);
if (locktype == NFS_NODE_LOCK_SHARED) {
lck_rw_lock_shared(&np->n_lock);
} else {
lck_rw_lock_exclusive(&np->n_lock);
np->n_lockowner = current_thread();
}
if ((locktype != NFS_NODE_LOCK_FORCE) && !(np->n_hflag && NHHASHED)) {
FSDBG_BOT(268, np, 0xdead, np->n_lockowner, 0);
nfs_unlock(np);
return (ENOENT);
}
FSDBG_BOT(268, np, locktype, np->n_lockowner, 0);
return (0);
}
void
nfs_unlock(nfsnode_t np)
{
FSDBG(269, np, np->n_lockowner, current_thread(), 0);
np->n_lockowner = NULL;
lck_rw_done(&np->n_lock);
}
int
nfs_lock2(nfsnode_t np1, nfsnode_t np2, int locktype)
{
int error;
if ((error = nfs_lock(np1, locktype)))
return (error);
if (np1 == np2)
return (error);
if ((error = nfs_lock(np2, locktype)))
nfs_unlock(np1);
return (error);
}
void
nfs_unlock2(nfsnode_t np1, nfsnode_t np2)
{
nfs_unlock(np1);
if (np1 != np2)
nfs_unlock(np2);
}
int
nfs_lock4(nfsnode_t fdnp, nfsnode_t fnp, nfsnode_t tdnp, nfsnode_t tnp, int locktype)
{
nfsnode_t list[4];
int i, lcnt = 0, error;
if (fdnp == tdnp) {
list[lcnt++] = fdnp;
} else if (fdnp->n_parent && (tdnp == VTONFS(fdnp->n_parent))) {
list[lcnt++] = tdnp;
list[lcnt++] = fdnp;
} else if (tdnp->n_parent && (fdnp == VTONFS(tdnp->n_parent))) {
list[lcnt++] = fdnp;
list[lcnt++] = tdnp;
} else if (fdnp < tdnp) {
list[lcnt++] = fdnp;
list[lcnt++] = tdnp;
} else {
list[lcnt++] = tdnp;
list[lcnt++] = fdnp;
}
if (!tnp || (fnp == tnp) || (tnp == fdnp)) {
list[lcnt++] = fnp;
} else if (fnp < tnp) {
list[lcnt++] = fnp;
list[lcnt++] = tnp;
} else {
list[lcnt++] = tnp;
list[lcnt++] = fnp;
}
for (i = 0; i < lcnt; ++i) {
if (list[i])
if ((error = nfs_lock(list[i], locktype))) {
while (--i >= 0) {
if (list[i])
nfs_unlock(list[i]);
}
return (error);
}
}
return (0);
}
void
nfs_unlock4(nfsnode_t np1, nfsnode_t np2, nfsnode_t np3, nfsnode_t np4)
{
nfsnode_t list[4];
int i, k = 0;
if (np1) {
nfs_unlock(np1);
list[k++] = np1;
}
if (np2) {
for (i = 0; i < k; ++i)
if (list[i] == np2)
goto skip2;
nfs_unlock(np2);
list[k++] = np2;
}
skip2:
if (np3) {
for (i = 0; i < k; ++i)
if (list[i] == np3)
goto skip3;
nfs_unlock(np3);
list[k++] = np3;
}
skip3:
if (np4) {
for (i = 0; i < k; ++i)
if (list[i] == np4)
return;
nfs_unlock(np4);
}
}
void
nfs_data_lock(nfsnode_t np, int locktype)
{
nfs_data_lock2(np, locktype, 1);
}
void
nfs_data_lock2(nfsnode_t np, int locktype, int updatesize)
{
FSDBG_TOP(270, np, locktype, np->n_datalockowner, 0);
if (locktype == NFS_NODE_LOCK_SHARED) {
if (updatesize && ISSET(np->n_flag, NUPDATESIZE))
nfs_data_update_size(np, 0);
lck_rw_lock_shared(&np->n_datalock);
} else {
lck_rw_lock_exclusive(&np->n_datalock);
np->n_datalockowner = current_thread();
if (updatesize && ISSET(np->n_flag, NUPDATESIZE))
nfs_data_update_size(np, 1);
}
FSDBG_BOT(270, np, locktype, np->n_datalockowner, 0);
}
void
nfs_data_unlock(nfsnode_t np)
{
nfs_data_unlock2(np, 1);
}
void
nfs_data_unlock2(nfsnode_t np, int updatesize)
{
int mine = (np->n_datalockowner == current_thread());
FSDBG_TOP(271, np, np->n_datalockowner, current_thread(), 0);
if (updatesize && mine && ISSET(np->n_flag, NUPDATESIZE))
nfs_data_update_size(np, 1);
np->n_datalockowner = NULL;
lck_rw_done(&np->n_datalock);
if (updatesize && !mine && ISSET(np->n_flag, NUPDATESIZE))
nfs_data_update_size(np, 0);
FSDBG_BOT(271, np, np->n_datalockowner, current_thread(), 0);
}
void
nfs_data_update_size(nfsnode_t np, int datalocked)
{
int error;
FSDBG_TOP(272, np, np->n_flag, np->n_size, np->n_newsize);
if (!datalocked) {
nfs_data_lock(np, NFS_NODE_LOCK_EXCLUSIVE);
nfs_data_unlock(np);
FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize);
return;
}
error = nfs_lock(np, NFS_NODE_LOCK_EXCLUSIVE);
if (error || !ISSET(np->n_flag, NUPDATESIZE)) {
if (!error)
nfs_unlock(np);
FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize);
return;
}
CLR(np->n_flag, NUPDATESIZE);
np->n_size = np->n_newsize;
SET(np->n_flag, NNEEDINVALIDATE);
nfs_unlock(np);
ubc_setsize(NFSTOV(np), (off_t)np->n_size);
FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize);
}