#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/kauth.h>
#include <sys/mount_internal.h>
#include <sys/vnode_internal.h>
#include <sys/vnode.h>
#include <sys/ubc.h>
#include <sys/malloc.h>
#include <sys/fcntl.h>
#include <sys/time.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;
static lck_grp_t *nfs_data_lck_grp;
lck_mtx_t *nfs_node_hash_mutex;
#define NFS_NODE_DBG(...) NFS_DBG(NFS_FAC_NODE, 7, ## __VA_ARGS__)
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);
nfs_data_lck_grp = lck_grp_alloc_init("nfs_data", 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_case_insensitive(mount_t);
int
nfs_case_insensitive(mount_t mp)
{
struct nfsmount *nmp = VFSTONFS(mp);
int answer = 0;
int skip = 0;
if (nfs_mount_gone(nmp)) {
return (0);
}
if (nmp->nm_vers == NFS_VER2) {
return (0);
}
lck_mtx_lock(&nmp->nm_lock);
if (nmp->nm_vers == NFS_VER3) {
if (!(nmp->nm_state & NFSSTA_GOTPATHCONF)) {
skip = 1;
}
} else if (!(nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_HOMOGENEOUS)) {
skip = 1;
}
if (!skip && (nmp->nm_fsattr.nfsa_flags & NFS_FSFLAG_CASE_INSENSITIVE))
answer = 1;
lck_mtx_unlock(&nmp->nm_lock);
return (answer);
}
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,
uint32_t auth,
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 || vfs_isforce(mp)) {
*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;
if (nvap && (nvap->nva_flags & NFS_FFLAG_TRIGGER_REFERRAL) &&
cnp && (cnp->cn_namelen > (fhsize - (int)sizeof(dnp)))) {
int namecmp = 0;
const char *vname = vnode_getname(NFSTOV(np));
if (vname) {
if (cnp->cn_namelen != (int)strlen(vname))
namecmp = 1;
else
namecmp = strncmp(vname, cnp->cn_nameptr, cnp->cn_namelen);
vnode_putname(vname);
}
if (namecmp)
continue;
}
FSDBG(263, dnp, np, np->n_flag, 0xcace0000);
if ((np->n_hflag & NHLOCKED) && !(flags & NG_NOCREATE)) {
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_node_lock(np))) {
FSDBG(263, dnp, *npp, 0xcaced1e2, error);
vnode_put(vp);
if (flags & NG_NOCREATE) {
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0xcaced1e0, ENOENT);
return (ENOENT);
}
goto loop;
}
if (nvap)
error = nfs_loadattrcache(np, nvap, xidp, 0);
if (error) {
nfs_node_unlock(np);
vnode_put(vp);
} else {
if (dnp && cnp && (flags & NG_MAKEENTRY))
cache_enter(NFSTOV(dnp), vp, cnp);
if (dnp && cnp && (vp != NFSTOV(dnp))) {
int update_flags = (vnode_ismonitored((NFSTOV(dnp)))) ? VNODE_UPDATE_CACHE : 0;
int (*cmp)(const char *s1, const char *s2, size_t n);
cmp = nfs_case_insensitive(mp) ? strncasecmp : strncmp;
if (vp->v_name && cnp->cn_namelen && (*cmp)(cnp->cn_nameptr, vp->v_name, cnp->cn_namelen))
update_flags |= VNODE_UPDATE_NAME;
if ((vp->v_name == NULL && cnp->cn_namelen != 0) || (vp->v_name != NULL && cnp->cn_namelen == 0))
update_flags |= VNODE_UPDATE_NAME;
if (vnode_parent(vp) != NFSTOV(dnp))
update_flags |= VNODE_UPDATE_PARENT;
if (update_flags) {
NFS_NODE_DBG("vnode_update_identity old name %s new name %.*s update flags = %x\n",
vp->v_name, cnp->cn_namelen, cnp->cn_nameptr ? cnp->cn_nameptr : "", update_flags);
vnode_update_identity(vp, NFSTOV(dnp), cnp->cn_nameptr, cnp->cn_namelen, 0, update_flags);
}
}
*npp = np;
}
FSDBG_BOT(263, dnp, *npp, 0xcace0000, error);
return(error);
}
FSDBG(263, mp, dnp, npp, 0xaaaaaaaa);
if (flags & NG_NOCREATE) {
lck_mtx_unlock(nfs_node_hash_mutex);
*npp = 0;
FSDBG_BOT(263, dnp, *npp, 0x80000001, ENOENT);
return (ENOENT);
}
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;
np->n_auth = auth;
TAILQ_INIT(&np->n_opens);
TAILQ_INIT(&np->n_lock_owners);
TAILQ_INIT(&np->n_locks);
np->n_dlink.tqe_next = NFSNOLIST;
np->n_dreturn.tqe_next = NFSNOLIST;
np->n_monlink.le_next = NFSNOLIST;
if ((nvap->nva_type == VDIR) && cnp && (cnp->cn_namelen == 4) &&
(cnp->cn_nameptr[0] == '.') && (cnp->cn_nameptr[1] == 'z') &&
(cnp->cn_nameptr[2] == 'f') && (cnp->cn_nameptr[3] == 's'))
np->n_flag |= NISDOTZFS;
if (dnp && (dnp->n_flag & NISDOTZFS))
np->n_flag |= NISDOTZFSCHILD;
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_mtx_init(&np->n_lock, nfs_node_lck_grp, LCK_ATTR_NULL);
lck_rw_init(&np->n_datalock, nfs_data_lck_grp, LCK_ATTR_NULL);
lck_mtx_init(&np->n_openlock, nfs_open_grp, LCK_ATTR_NULL);
lck_mtx_lock(&np->n_lock);
lck_mtx_unlock(nfs_node_hash_mutex);
NACLINVALIDATE(np);
NACCESSINVALIDATE(np);
error = nfs_loadattrcache(np, nvap, xidp, 1);
if (error) {
FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
nfs_node_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_mtx_destroy(&np->n_lock, nfs_node_lck_grp);
lck_rw_destroy(&np->n_datalock, nfs_data_lck_grp);
lck_mtx_destroy(&np->n_openlock, nfs_open_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);
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;
#if CONFIG_TRIGGERS
if ((nfsvers >= NFS_VER4) && (nvap->nva_type == VDIR) && (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER)) {
struct vnode_trigger_param vtp;
bzero(&vtp, sizeof(vtp));
bcopy(&vfsp, &vtp.vnt_params, sizeof(vfsp));
vtp.vnt_resolve_func = nfs_mirror_mount_trigger_resolve;
vtp.vnt_unresolve_func = nfs_mirror_mount_trigger_unresolve;
vtp.vnt_rearm_func = nfs_mirror_mount_trigger_rearm;
vtp.vnt_flags = VNT_AUTO_REARM;
error = vnode_create(VNCREATE_TRIGGER, VNCREATE_TRIGGER_SIZE, &vtp, &np->n_vnode);
} else
#endif
{
error = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &vfsp, &np->n_vnode);
}
if (error) {
FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
nfs_node_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_mtx_destroy(&np->n_lock, nfs_node_lck_grp);
lck_rw_destroy(&np->n_datalock, nfs_data_lck_grp);
lck_mtx_destroy(&np->n_openlock, nfs_open_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(
struct vnop_inactive_args *ap)
{
vnode_t vp = ap->a_vp;
vfs_context_t ctx = ap->a_context;
nfsnode_t np;
struct nfs_sillyrename *nsp;
struct nfs_vattr nvattr;
int unhash, attrerr, busyerror, error, inuse, busied, force;
struct nfs_open_file *nofp;
struct componentname cn;
struct nfsmount *nmp;
mount_t mp;
if (vp == NULL)
panic("nfs_vnop_inactive: vp == NULL");
np = VTONFS(vp);
if (np == NULL)
panic("nfs_vnop_inactive: np == NULL");
nmp = NFSTONMP(np);
mp = vnode_mount(vp);
restart:
force = (!mp || vfs_isforce(mp));
error = 0;
inuse = (nfs_mount_state_in_use_start(nmp, NULL) == 0);
lck_mtx_lock(&np->n_openlock);
if (np->n_openrefcnt && !force) {
#ifdef NFS_NODE_DEBUG
NP(np, "nfs_vnop_inactive: still open: %d", np->n_openrefcnt);
#endif
lck_mtx_unlock(&np->n_openlock);
return 0;
}
TAILQ_FOREACH(nofp, &np->n_opens, nof_link) {
lck_mtx_lock(&nofp->nof_lock);
if (nofp->nof_flags & NFS_OPEN_FILE_BUSY) {
if (!force)
NP(np, "nfs_vnop_inactive: open file busy");
busied = 0;
} else {
nofp->nof_flags |= NFS_OPEN_FILE_BUSY;
busied = 1;
}
lck_mtx_unlock(&nofp->nof_lock);
if ((np->n_flag & NREVOKE) || (nofp->nof_flags & NFS_OPEN_FILE_LOST)) {
if (busied)
nfs_open_file_clear_busy(nofp);
continue;
}
if ((nofp->nof_flags & NFS_OPEN_FILE_CREATE) && nofp->nof_creator && !force) {
if (nofp->nof_flags & NFS_OPEN_FILE_REOPEN) {
lck_mtx_unlock(&np->n_openlock);
if (busied)
nfs_open_file_clear_busy(nofp);
if (inuse)
nfs_mount_state_in_use_end(nmp, 0);
if (!nfs4_reopen(nofp, NULL))
goto restart;
}
nofp->nof_flags &= ~NFS_OPEN_FILE_CREATE;
lck_mtx_unlock(&np->n_openlock);
error = nfs_close(np, nofp, NFS_OPEN_SHARE_ACCESS_BOTH, NFS_OPEN_SHARE_DENY_NONE, ctx);
if (error) {
NP(np, "nfs_vnop_inactive: create close error: %d", error);
nofp->nof_flags |= NFS_OPEN_FILE_CREATE;
}
if (busied)
nfs_open_file_clear_busy(nofp);
if (inuse)
nfs_mount_state_in_use_end(nmp, error);
goto restart;
}
if (nofp->nof_flags & NFS_OPEN_FILE_NEEDCLOSE) {
nofp->nof_flags &= ~NFS_OPEN_FILE_NEEDCLOSE;
if ((nofp->nof_flags & NFS_OPEN_FILE_REOPEN) && (nofp->nof_opencnt == 1)) {
nofp->nof_flags &= ~NFS_OPEN_FILE_REOPEN;
nofp->nof_r--;
nofp->nof_opencnt--;
nofp->nof_access = 0;
} else if (!force) {
lck_mtx_unlock(&np->n_openlock);
if (nofp->nof_flags & NFS_OPEN_FILE_REOPEN) {
if (busied)
nfs_open_file_clear_busy(nofp);
if (inuse)
nfs_mount_state_in_use_end(nmp, 0);
if (!nfs4_reopen(nofp, NULL))
goto restart;
}
error = nfs_close(np, nofp, NFS_OPEN_SHARE_ACCESS_READ, NFS_OPEN_SHARE_DENY_NONE, ctx);
if (error) {
NP(np, "nfs_vnop_inactive: need close error: %d", error);
nofp->nof_flags |= NFS_OPEN_FILE_NEEDCLOSE;
}
if (busied)
nfs_open_file_clear_busy(nofp);
if (inuse)
nfs_mount_state_in_use_end(nmp, error);
goto restart;
}
}
if (nofp->nof_opencnt && !force)
NP(np, "nfs_vnop_inactive: file still open: %d", nofp->nof_opencnt);
if (!force && (nofp->nof_access || nofp->nof_deny ||
nofp->nof_mmap_access || nofp->nof_mmap_deny ||
nofp->nof_r || nofp->nof_w || nofp->nof_rw ||
nofp->nof_r_dw || nofp->nof_w_dw || nofp->nof_rw_dw ||
nofp->nof_r_drw || nofp->nof_w_drw || nofp->nof_rw_drw ||
nofp->nof_d_r || nofp->nof_d_w || nofp->nof_d_rw ||
nofp->nof_d_r_dw || nofp->nof_d_w_dw || nofp->nof_d_rw_dw ||
nofp->nof_d_r_drw || nofp->nof_d_w_drw || nofp->nof_d_rw_drw)) {
NP(np, "nfs_vnop_inactive: non-zero access: %d %d %d %d # %u.%u %u.%u %u.%u dw %u.%u %u.%u %u.%u drw %u.%u %u.%u %u.%u",
nofp->nof_access, nofp->nof_deny,
nofp->nof_mmap_access, nofp->nof_mmap_deny,
nofp->nof_r, nofp->nof_d_r,
nofp->nof_w, nofp->nof_d_w,
nofp->nof_rw, nofp->nof_d_rw,
nofp->nof_r_dw, nofp->nof_d_r_dw,
nofp->nof_w_dw, nofp->nof_d_w_dw,
nofp->nof_rw_dw, nofp->nof_d_rw_dw,
nofp->nof_r_drw, nofp->nof_d_r_drw,
nofp->nof_w_drw, nofp->nof_d_w_drw,
nofp->nof_rw_drw, nofp->nof_d_rw_drw);
}
if (busied)
nfs_open_file_clear_busy(nofp);
}
lck_mtx_unlock(&np->n_openlock);
if (inuse && nfs_mount_state_in_use_end(nmp, error))
goto restart;
nfs_node_lock_force(np);
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_node_unlock(np);
FSDBG_BOT(264, vp, np, np->n_flag, 0);
return (0);
}
nfs_node_unlock(np);
nfs_vinvalbuf2(vp, V_SAVE, vfs_context_thread(ctx), nsp->nsr_cred, 1);
attrerr = nfs_getattr(np, &nvattr, ctx, NGA_UNCACHED);
if (vnode_isinuse(vp, 0) || (!attrerr && (nvattr.nva_nlink > 1))) {
unhash = 0;
} else {
unhash = 1;
ubc_setsize(vp, 0);
}
busyerror = nfs_node_set_busy2(nsp->nsr_dnp, np, vfs_context_thread(ctx));
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);
bzero(&cn, sizeof(cn));
cn.cn_nameptr = nsp->nsr_name;
cn.cn_namelen = nsp->nsr_namlen;
nfs_name_cache_purge(nsp->nsr_dnp, np, &cn, ctx);
FSDBG(264, np, np->n_size, np->n_vattr.nva_size, 0xf00d00f1);
nfs_removeit(nsp);
nfs_node_lock_force(np);
np->n_flag &= (NMODIFIED);
nfs_node_unlock(np);
if (!busyerror)
nfs_node_clear_busy2(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(
struct vnop_reclaim_args *ap)
{
vnode_t vp = ap->a_vp;
nfsnode_t np = VTONFS(vp);
vfs_context_t ctx = ap->a_context;
struct nfs_open_file *nofp, *nextnofp;
struct nfs_file_lock *nflp, *nextnflp;
struct nfs_lock_owner *nlop, *nextnlop;
struct nfsmount *nmp = np->n_mount ? VFSTONFS(np->n_mount) : NFSTONMP(np);
mount_t mp = vnode_mount(vp);
int force;
FSDBG_TOP(265, vp, np, np->n_flag, 0);
force = (!mp || vfs_isforce(mp) || nfs_mount_gone(nmp));
lck_mtx_lock(&np->n_openlock);
if (nmp && (nmp->nm_vers >= NFS_VER4)) {
if (np->n_dreturn.tqe_next != NFSNOLIST) {
lck_mtx_lock(&nmp->nm_lock);
if (np->n_dreturn.tqe_next != NFSNOLIST) {
TAILQ_REMOVE(&nmp->nm_dreturnq, np, n_dreturn);
np->n_dreturn.tqe_next = NFSNOLIST;
}
lck_mtx_unlock(&nmp->nm_lock);
}
if (np->n_dlink.tqe_next != NFSNOLIST) {
lck_mtx_lock(&nmp->nm_lock);
if (np->n_dlink.tqe_next != NFSNOLIST) {
TAILQ_REMOVE(&nmp->nm_delegations, np, n_dlink);
np->n_dlink.tqe_next = NFSNOLIST;
}
lck_mtx_unlock(&nmp->nm_lock);
}
if ((np->n_openflags & N_DELEG_MASK) && !force) {
np->n_openflags &= ~N_DELEG_MASK;
nfs4_delegreturn_rpc(nmp, np->n_fhp, np->n_fhsize, &np->n_dstateid,
R_RECOVER, vfs_context_thread(ctx), vfs_context_ucred(ctx));
}
if (np->n_attrdirfh) {
FREE(np->n_attrdirfh, M_TEMP);
np->n_attrdirfh = NULL;
}
}
TAILQ_FOREACH_SAFE(nflp, &np->n_locks, nfl_link, nextnflp) {
if (!(nflp->nfl_flags & NFS_FILE_LOCK_DEAD) && !force) {
NP(np, "nfs_vnop_reclaim: lock 0x%llx 0x%llx 0x%x (bc %d)",
nflp->nfl_start, nflp->nfl_end, nflp->nfl_flags, nflp->nfl_blockcnt);
}
if (!(nflp->nfl_flags & (NFS_FILE_LOCK_BLOCKED|NFS_FILE_LOCK_DEAD))) {
if (!(nflp->nfl_flags & NFS_FILE_LOCK_DELEGATED) && !force)
nmp->nm_funcs->nf_unlock_rpc(np, nflp->nfl_owner, F_WRLCK, nflp->nfl_start, nflp->nfl_end, R_RECOVER,
NULL, nflp->nfl_owner->nlo_open_owner->noo_cred);
lck_mtx_lock(&nflp->nfl_owner->nlo_lock);
TAILQ_REMOVE(&nflp->nfl_owner->nlo_locks, nflp, nfl_lolink);
lck_mtx_unlock(&nflp->nfl_owner->nlo_lock);
}
TAILQ_REMOVE(&np->n_locks, nflp, nfl_link);
nfs_file_lock_destroy(nflp);
}
TAILQ_FOREACH_SAFE(nlop, &np->n_lock_owners, nlo_link, nextnlop) {
if (!TAILQ_EMPTY(&nlop->nlo_locks) && !force)
NP(np, "nfs_vnop_reclaim: lock owner with locks");
TAILQ_REMOVE(&np->n_lock_owners, nlop, nlo_link);
nfs_lock_owner_destroy(nlop);
}
if (np->n_openrefcnt && !force)
NP(np, "nfs_vnop_reclaim: still open: %d", np->n_openrefcnt);
TAILQ_FOREACH_SAFE(nofp, &np->n_opens, nof_link, nextnofp) {
if (nofp->nof_flags & NFS_OPEN_FILE_BUSY)
NP(np, "nfs_vnop_reclaim: open file busy");
if (!(np->n_flag & NREVOKE) && !(nofp->nof_flags & NFS_OPEN_FILE_LOST)) {
if (nofp->nof_opencnt && !force)
NP(np, "nfs_vnop_reclaim: file still open: %d", nofp->nof_opencnt);
if (!force && (nofp->nof_access || nofp->nof_deny ||
nofp->nof_mmap_access || nofp->nof_mmap_deny ||
nofp->nof_r || nofp->nof_w || nofp->nof_rw ||
nofp->nof_r_dw || nofp->nof_w_dw || nofp->nof_rw_dw ||
nofp->nof_r_drw || nofp->nof_w_drw || nofp->nof_rw_drw ||
nofp->nof_d_r || nofp->nof_d_w || nofp->nof_d_rw ||
nofp->nof_d_r_dw || nofp->nof_d_w_dw || nofp->nof_d_rw_dw ||
nofp->nof_d_r_drw || nofp->nof_d_w_drw || nofp->nof_d_rw_drw)) {
NP(np, "nfs_vnop_reclaim: non-zero access: %d %d %d %d # %u.%u %u.%u %u.%u dw %u.%u %u.%u %u.%u drw %u.%u %u.%u %u.%u",
nofp->nof_access, nofp->nof_deny,
nofp->nof_mmap_access, nofp->nof_mmap_deny,
nofp->nof_r, nofp->nof_d_r,
nofp->nof_w, nofp->nof_d_w,
nofp->nof_rw, nofp->nof_d_rw,
nofp->nof_r_dw, nofp->nof_d_r_dw,
nofp->nof_w_dw, nofp->nof_d_w_dw,
nofp->nof_rw_dw, nofp->nof_d_rw_dw,
nofp->nof_r_drw, nofp->nof_d_r_drw,
nofp->nof_w_drw, nofp->nof_d_w_drw,
nofp->nof_rw_drw, nofp->nof_d_rw_drw);
if (nofp->nof_r || nofp->nof_w || nofp->nof_rw ||
nofp->nof_r_dw || nofp->nof_w_dw || nofp->nof_rw_dw ||
nofp->nof_r_drw || nofp->nof_w_drw || nofp->nof_rw_drw)
nfs4_close_rpc(np, nofp, NULL, nofp->nof_owner->noo_cred, R_RECOVER);
}
}
TAILQ_REMOVE(&np->n_opens, nofp, nof_link);
nfs_open_file_destroy(nofp);
}
lck_mtx_unlock(&np->n_openlock);
if (np->n_monlink.le_next != NFSNOLIST) {
lck_mtx_lock(&nmp->nm_lock);
while (np->n_mflag & NMMONSCANINPROG) {
struct timespec ts = { 1, 0 };
np->n_mflag |= NMMONSCANWANT;
msleep(&np->n_mflag, &nmp->nm_lock, PZERO-1, "nfswaitmonscan", &ts);
}
if (np->n_monlink.le_next != NFSNOLIST) {
LIST_REMOVE(np, n_monlink);
np->n_monlink.le_next = NFSNOLIST;
}
lck_mtx_unlock(&nmp->nm_lock);
}
lck_mtx_lock(nfs_buf_mutex);
if (!force && (!LIST_EMPTY(&np->n_dirtyblkhd) || !LIST_EMPTY(&np->n_cleanblkhd)))
NP(np, "nfs_reclaim: dropping %s buffers", (!LIST_EMPTY(&np->n_dirtyblkhd) ? "dirty" : "clean"));
lck_mtx_unlock(nfs_buf_mutex);
nfs_vinvalbuf(vp, V_IGNORE_WRITEERR, ap->a_context, 0);
lck_mtx_lock(nfs_node_hash_mutex);
if ((vnode_vtype(vp) != VDIR) && np->n_sillyrename) {
if (!force)
NP(np, "nfs_reclaim: leaving unlinked file %s", np->n_sillyrename->nsr_name);
if (np->n_sillyrename->nsr_cred != NOCRED)
kauth_cred_unref(&np->n_sillyrename->nsr_cred);
vnode_rele(NFSTOV(np->n_sillyrename->nsr_dnp));
FREE_ZONE(np->n_sillyrename, sizeof(*np->n_sillyrename), M_NFSREQ);
}
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_node_lock_force(np);
if ((vnode_vtype(vp) == VDIR) && np->n_cookiecache)
FREE_ZONE(np->n_cookiecache, sizeof(struct nfsdmap), M_NFSDIROFF);
if (np->n_fhsize > NFS_SMALLFH)
FREE_ZONE(np->n_fhp, np->n_fhsize, M_NFSBIGFH);
if (np->n_vattr.nva_acl)
kauth_acl_free(np->n_vattr.nva_acl);
nfs_node_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_mtx_destroy(&np->n_lock, nfs_node_lck_grp);
lck_rw_destroy(&np->n_datalock, nfs_data_lck_grp);
lck_mtx_destroy(&np->n_openlock, nfs_open_grp);
FSDBG_BOT(265, vp, np, np->n_flag, 0xd1ed1e);
FREE_ZONE(np, sizeof(struct nfsnode), M_NFSNODE);
return (0);
}
int
nfs_node_lock_internal(nfsnode_t np, int force)
{
FSDBG_TOP(268, np, force, 0, 0);
lck_mtx_lock(&np->n_lock);
if (!force && !(np->n_hflag && NHHASHED)) {
FSDBG_BOT(268, np, 0xdead, 0, 0);
lck_mtx_unlock(&np->n_lock);
return (ENOENT);
}
FSDBG_BOT(268, np, force, 0, 0);
return (0);
}
int
nfs_node_lock(nfsnode_t np)
{
return nfs_node_lock_internal(np, 0);
}
void
nfs_node_lock_force(nfsnode_t np)
{
nfs_node_lock_internal(np, 1);
}
void
nfs_node_unlock(nfsnode_t np)
{
FSDBG(269, np, current_thread(), 0, 0);
lck_mtx_unlock(&np->n_lock);
}
int
nfs_node_lock2(nfsnode_t np1, nfsnode_t np2)
{
nfsnode_t first, second;
int error;
first = (np1 > np2) ? np1 : np2;
second = (np1 > np2) ? np2 : np1;
if ((error = nfs_node_lock(first)))
return (error);
if (np1 == np2)
return (error);
if ((error = nfs_node_lock(second)))
nfs_node_unlock(first);
return (error);
}
void
nfs_node_unlock2(nfsnode_t np1, nfsnode_t np2)
{
nfs_node_unlock(np1);
if (np1 != np2)
nfs_node_unlock(np2);
}
int
nfs_node_set_busy(nfsnode_t np, thread_t thd)
{
struct timespec ts = { 2, 0 };
int error;
if ((error = nfs_node_lock(np)))
return (error);
while (ISSET(np->n_flag, NBUSY)) {
SET(np->n_flag, NBUSYWANT);
msleep(np, &np->n_lock, PZERO-1, "nfsbusywant", &ts);
if ((error = nfs_sigintr(NFSTONMP(np), NULL, thd, 0)))
break;
}
if (!error)
SET(np->n_flag, NBUSY);
nfs_node_unlock(np);
return (error);
}
void
nfs_node_clear_busy(nfsnode_t np)
{
int wanted;
nfs_node_lock_force(np);
wanted = ISSET(np->n_flag, NBUSYWANT);
CLR(np->n_flag, NBUSY|NBUSYWANT);
nfs_node_unlock(np);
if (wanted)
wakeup(np);
}
int
nfs_node_set_busy2(nfsnode_t np1, nfsnode_t np2, thread_t thd)
{
nfsnode_t first, second;
int error;
first = (np1 > np2) ? np1 : np2;
second = (np1 > np2) ? np2 : np1;
if ((error = nfs_node_set_busy(first, thd)))
return (error);
if (np1 == np2)
return (error);
if ((error = nfs_node_set_busy(second, thd)))
nfs_node_clear_busy(first);
return (error);
}
void
nfs_node_clear_busy2(nfsnode_t np1, nfsnode_t np2)
{
nfs_node_clear_busy(np1);
if (np1 != np2)
nfs_node_clear_busy(np2);
}
static void
nfs_node_sort4(nfsnode_t np1, nfsnode_t np2, nfsnode_t np3, nfsnode_t np4, nfsnode_t *list, int *lcntp)
{
nfsnode_t na[2], nb[2];
int a, b, i, lcnt;
na[0] = (np1 > np2) ? np1 : np2;
na[1] = (np1 > np2) ? np2 : np1;
nb[0] = (np3 > np4) ? np3 : np4;
nb[1] = (np3 > np4) ? np4 : np3;
for (a = b = i = lcnt = 0; i < 4; i++) {
if (a >= 2)
list[lcnt] = nb[b++];
else if ((b >= 2) || (na[a] >= nb[b]))
list[lcnt] = na[a++];
else
list[lcnt] = nb[b++];
if ((lcnt <= 0) || (list[lcnt] != list[lcnt-1]))
lcnt++;
}
if (list[lcnt-1] == NULL)
lcnt--;
*lcntp = lcnt;
}
int
nfs_node_set_busy4(nfsnode_t np1, nfsnode_t np2, nfsnode_t np3, nfsnode_t np4, thread_t thd)
{
nfsnode_t list[4];
int i, lcnt, error;
nfs_node_sort4(np1, np2, np3, np4, list, &lcnt);
for (i = 0; i < lcnt; ++i)
if ((error = nfs_node_set_busy(list[i], thd))) {
while (--i >= 0)
nfs_node_clear_busy(list[i]);
return (error);
}
return (0);
}
void
nfs_node_clear_busy4(nfsnode_t np1, nfsnode_t np2, nfsnode_t np3, nfsnode_t np4)
{
nfsnode_t list[4];
int lcnt;
nfs_node_sort4(np1, np2, np3, np4, list, &lcnt);
while (--lcnt >= 0)
nfs_node_clear_busy(list[lcnt]);
}
void
nfs_data_lock(nfsnode_t np, int locktype)
{
nfs_data_lock_internal(np, locktype, 1);
}
void
nfs_data_lock_noupdate(nfsnode_t np, int locktype)
{
nfs_data_lock_internal(np, locktype, 0);
}
void
nfs_data_lock_internal(nfsnode_t np, int locktype, int updatesize)
{
FSDBG_TOP(270, np, locktype, np->n_datalockowner, 0);
if (locktype == NFS_DATA_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_unlock_internal(np, 1);
}
void
nfs_data_unlock_noupdate(nfsnode_t np)
{
nfs_data_unlock_internal(np, 0);
}
void
nfs_data_unlock_internal(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_DATA_LOCK_EXCLUSIVE);
nfs_data_unlock(np);
FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize);
return;
}
error = nfs_node_lock(np);
if (error || !ISSET(np->n_flag, NUPDATESIZE)) {
if (!error)
nfs_node_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_node_unlock(np);
ubc_setsize(NFSTOV(np), (off_t)np->n_size);
FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize);
}
#define DODEBUG 1
int
nfs_mount_is_dirty(mount_t mp)
{
u_long i;
nfsnode_t np;
#ifdef DODEBUG
struct timeval now, then, diff;
u_long ncnt = 0;
microuptime(&now);
#endif
lck_mtx_lock(nfs_node_hash_mutex);
for (i = 0; i <= nfsnodehash; i++) {
LIST_FOREACH(np, &nfsnodehashtbl[i], n_hash) {
#ifdef DODEBUG
ncnt++;
#endif
if (np->n_mount == mp && !LIST_EMPTY(&np->n_dirtyblkhd))
goto out;
}
}
out:
lck_mtx_unlock(nfs_node_hash_mutex);
#ifdef DODEBUG
microuptime(&then);
timersub(&then, &now, &diff);
NFS_DBG(NFS_FAC_SOCK, 7, "mount_is_dirty for %s took %lld mics for %ld slots and %ld nodes return %d\n",
vfs_statfs(mp)->f_mntfromname, (uint64_t)diff.tv_sec * 1000000LL + diff.tv_usec, i, ncnt, (i <= nfsnodehash));
#endif
return (i <= nfsnodehash);
}