/*
 * Copyright (c) 2013 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Antonio Huete Jimenez <tuxillo@quantumachine.net>
 * by Matthew Dillon <dillon@dragonflybsd.org>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

#include <errno.h>
#include <fcntl.h>
#include <unistd.h>

#include <sys/mount.h>
#include <sys/queue.h>
#include <sys/spinlock2.h>
#include <sys/stat.h>
#include <sys/systm.h>
#include <sys/types.h>
#include <sys/vfscache.h>
#include <sys/vnode.h>

#include "dirfs.h"

/*
 * Allocate and setup all is needed for the dirfs node to hold the filename.
 * Note: dn_name is NULL terminated.
 */
void
dirfs_node_setname(dirfs_node_t dnp, const char *name, int len)
{
        dbg(5, "called\n");

        if (dnp->dn_name)
                kfree(dnp->dn_name, M_DIRFS_MISC);
        dnp->dn_name = kmalloc(len + 1, M_DIRFS_MISC, M_WAITOK | M_ZERO);
        bcopy(name, dnp->dn_name, len);
        dnp->dn_name[len] = 0;
        dnp->dn_namelen = len;
}

/*
 * Allocate enough space to hold a dirfs node structure.
 * Note: Node name and length isn't handled here.
 */
dirfs_node_t
dirfs_node_alloc(struct mount *mp)
{
        dirfs_node_t dnp;

        dbg(5, "called\n");

        dnp = kmalloc(sizeof(*dnp), M_DIRFS_NODE, M_WAITOK | M_ZERO);
        lockinit(&dnp->dn_lock, "dfsnode", 0, LK_CANRECURSE);

        dnp->dn_fd = DIRFS_NOFD;

        return dnp;
}

/*
 * Drops a reference to the node and. Node is freed when in the last reference.
 */
void
dirfs_node_drop(dirfs_mount_t dmp, dirfs_node_t dnp)
{
        dbg(5, "called\n");

        if (dirfs_node_unref(dnp))
                dirfs_node_free(dmp, dnp);
}

/*
 * Removes the association with its parent. Before freeing up its resources
 * the node will be removed from the per-mount passive fd cache and its fd
 * will be closed, either normally or forced.
 */
int
dirfs_node_free(dirfs_mount_t dmp, dirfs_node_t dnp)
{
        struct vnode *vp;

        dbg(5, "called\n");

        KKASSERT(dnp != NULL);
        debug_node2(dnp);

        KKASSERT(dirfs_node_refcnt(dnp) == 0);

        vp = NODE_TO_VP(dnp);
        /*
         * Remove the inode from the passive fds list
         * as we are tearing down the node.
         * Root inode will be removed on VOP_UNMOUNT()
         */
        if (dnp->dn_parent) {   /* NULL when children reaped parents */
                dirfs_node_drop(dmp, dnp->dn_parent);
                dnp->dn_parent = NULL;
        }
        dirfs_node_setpassive(dmp, dnp, 0);
        if (dnp->dn_name) {
                kfree(dnp->dn_name, M_DIRFS_MISC);
                dnp->dn_name = NULL;
        }

        /*
         * The file descriptor should have been closed already by the
         * previous call to dirfs_set-passive. If not, force a sync and
         * close it.
         */
        if (dnp->dn_fd != DIRFS_NOFD) {
                if (dnp->dn_vnode)
                        VOP_FSYNC(vp, MNT_WAIT, 0);
                close(dnp->dn_fd);
                dnp->dn_fd = DIRFS_NOFD;
        }

        lockuninit(&dnp->dn_lock);
        kfree(dnp, M_DIRFS_NODE);
        dnp = NULL;

        return 0;
}

/*
 * Do all the operations needed to get a resulting inode <--> host file
 * association. This or may not include opening the file, which should be
 * only needed when creating it.
 *
 * In the case vap is not NULL and openflags are specified, open the file.
 */
int
dirfs_alloc_file(dirfs_mount_t dmp, dirfs_node_t *dnpp, dirfs_node_t pdnp,
    struct namecache *ncp, struct vnode **vpp, struct vattr *vap,
    int openflags)
{
        dirfs_node_t dnp;
        dirfs_node_t pathnp;
        struct vnode *vp;
        struct mount *mp;
        char *tmp;
        char *pathfree;
        int error;

        dbg(5, "called\n");

        error = 0;
        vp = NULL;
        mp = DIRFS_TO_VFS(dmp);

        /* Sanity check */
        if (pdnp == NULL)
                return EINVAL;

        dnp = dirfs_node_alloc(mp);
        KKASSERT(dnp != NULL);

        dirfs_node_lock(dnp);
        dirfs_node_setname(dnp, ncp->nc_name, ncp->nc_nlen);
        dnp->dn_parent = pdnp;
        dirfs_node_ref(pdnp);   /* Children ref */
        dirfs_node_unlock(dnp);

        pathnp = dirfs_findfd(dmp, dnp, &tmp, &pathfree);

        if (openflags && vap != NULL) {
                dnp->dn_fd = openat(pathnp->dn_fd, tmp,
                                    openflags, vap->va_mode);
                if (dnp->dn_fd == -1) {
                        dirfs_dropfd(dmp, pathnp, pathfree);
                        return errno;
                }
        }

        error = dirfs_node_stat(pathnp->dn_fd, tmp, dnp);
        if (error) {            /* XXX Handle errors */
                error = errno;
                if (vp)
                        dirfs_free_vp(dmp, dnp);
                dirfs_node_free(dmp, dnp);
                dirfs_dropfd(dmp, pathnp, pathfree);
                return error;
        }

        dirfs_alloc_vp(mp, &vp, LK_CANRECURSE, dnp);
        *vpp = vp;
        *dnpp = dnp;

        dbg(9, "tmp=%s dnp=%p allocated\n", tmp, dnp);
        dirfs_dropfd(dmp, pathnp, pathfree);

        /* We want VOP_INACTIVE() to be called on last ref */
        atomic_set_int(&vp->v_refcnt, VREF_FINALIZE);

        return error;
}

/*
 * Requires an already dirfs_node_t that has been already lstat(2)
 * for the type comparison
 */
void
dirfs_alloc_vp(struct mount *mp, struct vnode **vpp, int lkflags,
               dirfs_node_t dnp)
{
        struct vnode *vp;
        dirfs_mount_t dmp = VFS_TO_DIRFS(mp);

        dbg(5, "called\n");

        /*
         * Handle vnode reclaim/alloc races
         */
        for (;;) {
                vp = dnp->dn_vnode;
                if (vp) {
                        if (vget(vp, LK_EXCLUSIVE) == 0)
                                break;  /* success */
                        /* vget raced a reclaim, retry */
                } else {
                        getnewvnode(VT_UNUSED10, mp, &vp, 0, lkflags);
                        if (dnp->dn_vnode == NULL) {
                                dnp->dn_vnode = vp;
                                vp->v_data = dnp;
                                vp->v_type = dnp->dn_type;
                                if (dmp->dm_root == dnp)
                                        vsetflags(vp, VROOT);
                                dirfs_node_ref(dnp);    /* ref for dnp<->vp */

                                /* Type-specific initialization. */
                                switch (dnp->dn_type) {
                                case VBLK:
                                case VCHR:
                                case VSOCK:
                                        break;
                                case VREG:
                                        vinitvmio(vp, dnp->dn_size, BMASK, -1);
                                        break;
                                case VLNK:
                                        break;
                                case VFIFO:
                        //              vp->v_ops = &mp->mnt_vn_fifo_ops;
                                        break;
                                case VDIR:
                                        break;
                                default:
                                        panic("dirfs_alloc_vp: dnp=%p vp=%p "
                                              "type=%d",
                                              dnp, vp, dnp->dn_type);
                                        /* NOT REACHED */
                                        break;
                                }
                                /* downgrade VX lock to VN lock */
                                vx_downgrade(vp);
                                break;  /* success */
                        }
                        vp->v_type = VBAD;
                        vx_put(vp);
                        /* multiple dirfs_alloc_vp calls raced, retry */
                }
        }
        KKASSERT(vp != NULL);
        *vpp = vp;
        dbg(9, "dnp=%p vp=%p type=%d\n", dnp, vp, vp->v_type);
}

/*
 * Do not call locked!
 */
void
dirfs_free_vp(dirfs_mount_t dmp, dirfs_node_t dnp)
{
        struct vnode *vp = NODE_TO_VP(dnp);

        dbg(5, "called\n");

        dnp->dn_vnode = NULL;
        vp->v_data = NULL;
        dirfs_node_drop(dmp, dnp);
}

int
dirfs_nodetype(struct stat *st)
{
        int ret;
        mode_t mode = st->st_mode;

        if (S_ISDIR(mode))
                ret = VDIR;
        else if (S_ISBLK(mode))
                ret = VBLK;
        else if (S_ISCHR(mode))
                ret = VCHR;
        else if (S_ISFIFO(mode))
                ret = VFIFO;
        else if (S_ISSOCK(mode))
                ret = VSOCK;
        else if (S_ISLNK(mode))
                ret = VLNK;
        else if (S_ISREG(mode))
                ret = VREG;
        else
                ret = VBAD;

        return ret;
}

int
dirfs_node_stat(int fd, const char *path, dirfs_node_t dnp)
{
        struct stat st;
        int error;

        dbg(5, "called\n");
        if (fd == DIRFS_NOFD)
                error = lstat(path, &st);
        else
                error = fstatat(fd, path, &st, AT_SYMLINK_NOFOLLOW);

        if (error)
                return errno;

        /* Populate our dirfs node struct with stat data */
        dnp->dn_uid = st.st_uid;
        dnp->dn_gid = st.st_gid;
        dnp->dn_mode = st.st_mode;
        dnp->dn_flags = st.st_flags;
        dnp->dn_links = st.st_nlink;
        dnp->dn_atime = st.st_atime;
        dnp->dn_atimensec = (st.st_atime * 1000000000L);
        dnp->dn_mtime = st.st_mtime;
        dnp->dn_mtimensec = (st.st_mtime * 1000000000L);
        dnp->dn_ctime = st.st_ctime;
        dnp->dn_ctimensec = (st.st_ctime * 1000000000L);
        dnp->dn_gen = st.st_gen;
        dnp->dn_ino = st.st_ino;
        dnp->dn_st_dev = st.st_dev;
        dnp->dn_size = st.st_size;
        dnp->dn_type = dirfs_nodetype(&st);

        return 0;
}

char *
dirfs_node_absolute_path(dirfs_mount_t dmp, dirfs_node_t cur, char **pathfreep)
{
        return(dirfs_node_absolute_path_plus(dmp, cur, NULL, pathfreep));
}

char *
dirfs_node_absolute_path_plus(dirfs_mount_t dmp, dirfs_node_t cur,
                              char *last, char **pathfreep)
{
        size_t len;
        dirfs_node_t dnp1;
        char *buf;
        int count;

        dbg(5, "called\n");

        KKASSERT(dmp->dm_root); /* Sanity check */
        *pathfreep = NULL;
        if (cur == NULL)
                return NULL;
        buf = kmalloc(MAXPATHLEN + 1, M_DIRFS_MISC, M_WAITOK);

        /*
         * Passed-in trailing element.
         */
        count = 0;
        buf[MAXPATHLEN] = 0;
        if (last) {
                len = strlen(last);
                count += len;
                if (count <= MAXPATHLEN)
                        bcopy(last, &buf[MAXPATHLEN - count], len);
                ++count;
                if (count <= MAXPATHLEN)
                        buf[MAXPATHLEN - count] = '/';
        }

        /*
         * Iterate through the parents until we hit the root.
         */
        dnp1 = cur;
        while (dirfs_node_isroot(dnp1) == 0) {
                count += dnp1->dn_namelen;
                if (count <= MAXPATHLEN) {
                        bcopy(dnp1->dn_name, &buf[MAXPATHLEN - count],
                              dnp1->dn_namelen);
                }
                ++count;
                if (count <= MAXPATHLEN)
                        buf[MAXPATHLEN - count] = '/';
                dnp1 = dnp1->dn_parent;
                if (dnp1 == NULL)
                        break;
        }

        /*
         * Prefix with the root mount path.  If the element was unlinked
         * dnp1 will be NULL and there is no path.
         */
        len = strlen(dmp->dm_path);
        count += len;
        if (dnp1 && count <= MAXPATHLEN) {
                bcopy(dmp->dm_path, &buf[MAXPATHLEN - count], len);
                *pathfreep = buf;
                dbg(9, "absolute_path %s\n", &buf[MAXPATHLEN - count]);
                return (&buf[MAXPATHLEN - count]);
        } else {
                kfree(buf, M_DIRFS_MISC);
                *pathfreep = NULL;
                return (NULL);
        }
}

/*
 * Return a dirfs_node with a valid descriptor plus an allocated
 * relative path which can be used in openat(), fstatat(), etc calls
 * to locate the requested inode.
 */
dirfs_node_t
dirfs_findfd(dirfs_mount_t dmp, dirfs_node_t cur,
             char **pathto, char **pathfreep)
{
        dirfs_node_t dnp1;
        int count;
        char *buf;

        dbg(5, "called\n");

        *pathfreep = NULL;
        *pathto = NULL;

        if (cur == NULL)
                return NULL;

        buf = kmalloc(MAXPATHLEN + 1, M_DIRFS_MISC, M_WAITOK | M_ZERO);
        count = 0;

        dnp1 = cur;
        while (dnp1 == cur || dnp1->dn_fd == DIRFS_NOFD) {
                count += dnp1->dn_namelen;
                if (count <= MAXPATHLEN) {
                        bcopy(dnp1->dn_name, &buf[MAXPATHLEN - count],
                              dnp1->dn_namelen);
                }
                ++count;
                if (count <= MAXPATHLEN)
                        buf[MAXPATHLEN - count] = '/';
                dnp1 = dnp1->dn_parent;
                KKASSERT(dnp1 != NULL);
        }

        if (dnp1 && count <= MAXPATHLEN) {
                *pathfreep = buf;
                *pathto = &buf[MAXPATHLEN - count + 1]; /* skip '/' prefix */
                dirfs_node_ref(dnp1);
                dbg(9, "fd=%d dnp1=%p dnp1->dn_name=%d &buf[off]=%s\n",
                    dnp1->dn_fd, dnp1, dnp1->dn_name, *pathto);
        } else {
                dbg(9, "failed too long\n");
                kfree(buf, M_DIRFS_MISC);
                *pathfreep = NULL;
                *pathto = NULL;
                dnp1 = NULL;
        }
        return (dnp1);
}

void
dirfs_dropfd(dirfs_mount_t dmp, dirfs_node_t dnp1, char *pathfree)
{
        if (pathfree)
                kfree(pathfree, M_DIRFS_MISC);
        if (dnp1)
                dirfs_node_drop(dmp, dnp1);
}

int
dirfs_node_getperms(dirfs_node_t dnp, int *flags)
{
        dirfs_mount_t dmp;
        struct vnode *vp = dnp->dn_vnode;
        int isowner;
        int isgroup;

        /*
         * There must be an active vnode anyways since that
         * would indicate the dirfs node has valid data for
         * for dnp->dn_mode (via lstat syscall).
         */
        KKASSERT(vp);
        dmp = VFS_TO_DIRFS(vp->v_mount);

        isowner = (dmp->dm_uid == dnp->dn_uid);
        isgroup = (dmp->dm_gid == dnp->dn_gid);

        if (isowner) {
                if (dnp->dn_mode & S_IRUSR)
                        *flags |= DIRFS_NODE_RD;
                if (dnp->dn_mode & S_IWUSR)
                        *flags |= DIRFS_NODE_WR;
                if (dnp->dn_mode & S_IXUSR)
                        *flags |= DIRFS_NODE_EXE;
        } else if (isgroup) {
                if (dnp->dn_mode & S_IRGRP)
                        *flags |= DIRFS_NODE_RD;
                if (dnp->dn_mode & S_IWGRP)
                        *flags |= DIRFS_NODE_WR;
                if (dnp->dn_mode & S_IXGRP)
                        *flags |= DIRFS_NODE_EXE;
        } else {
                if (dnp->dn_mode & S_IROTH)
                        *flags |= DIRFS_NODE_RD;
                if (dnp->dn_mode & S_IWOTH)
                        *flags |= DIRFS_NODE_WR;
                if (dnp->dn_mode & S_IXOTH)
                        *flags |= DIRFS_NODE_EXE;
        }

        return 0;
}

/*
 * This requires an allocated node and vnode, otherwise it'll panic
 */
int
dirfs_open_helper(dirfs_mount_t dmp, dirfs_node_t dnp, int parentfd,
                  char *relpath)
{
        dirfs_node_t pathnp;
        char *pathfree;
        char *tmp;
        int flags;
        int perms;
        int error;

        dbg(5, "called\n");

        flags = error = perms = 0;
        tmp = NULL;

        KKASSERT(dnp);
        KKASSERT(dnp->dn_vnode);

        /*
         * XXX Besides VDIR and VREG there are other file
         * types, y'know?
         * Also, O_RDWR alone might not be the best mode to open
         * a file with, need to investigate which suits better.
         */
        dirfs_node_getperms(dnp, &perms);

        if (dnp->dn_type & VDIR) {
                flags |= O_DIRECTORY;
        } else {
                if (perms & DIRFS_NODE_WR)
                        flags |= O_RDWR;
                else
                        flags |= O_RDONLY;
        }
        if (relpath != NULL) {
                tmp = relpath;
                pathnp = NULL;
                KKASSERT(parentfd != DIRFS_NOFD);
        } else if (parentfd == DIRFS_NOFD) {
                pathnp = dirfs_findfd(dmp, dnp, &tmp, &pathfree);
                parentfd = pathnp->dn_fd;
        } else {
                pathnp = NULL;
        }

        dnp->dn_fd = openat(parentfd, tmp, flags);
        if (dnp->dn_fd == -1)
                error = errno;

        dbg(9, "dnp=%p tmp2=%s parentfd=%d flags=%d error=%d "
            "flags=%08x w=%d x=%d\n", dnp, tmp, parentfd, flags, error,
            perms);

        if (pathnp)
                dirfs_dropfd(dmp, pathnp, pathfree);

        return error;
}

int
dirfs_close_helper(dirfs_node_t dnp)
{
        int error = 0;

        dbg(5, "called\n");


        if (dnp->dn_fd != DIRFS_NOFD) {
                dbg(9, "closed fd on dnp=%p\n", dnp);
#if 0
                /* buffer cache buffers may still be present */
                error = close(dnp->dn_fd); /* XXX EINTR should be checked */
                dnp->dn_fd = DIRFS_NOFD;
#endif
        }

        return error;
}

int
dirfs_node_refcnt(dirfs_node_t dnp)
{
        return dnp->dn_refcnt;
}

int
dirfs_node_chtimes(dirfs_node_t dnp)
{
        struct vnode *vp;
        dirfs_mount_t dmp;
        int error = 0;
        char *tmp;
        char *pathfree;

        vp = NODE_TO_VP(dnp);
        dmp = VFS_TO_DIRFS(vp->v_mount);

        KKASSERT(vn_islocked(vp));

        if (dnp->dn_flags & (IMMUTABLE | APPEND))
                return EPERM;

        tmp = dirfs_node_absolute_path(dmp, dnp, &pathfree);
        KKASSERT(tmp);
        if((lutimes(tmp, NULL)) == -1)
                error = errno;

        dirfs_node_stat(DIRFS_NOFD, tmp, dnp);
        dirfs_dropfd(dmp, NULL, pathfree);

        KKASSERT(vn_islocked(vp));


        return error;
}

int
dirfs_node_chflags(dirfs_node_t dnp, u_long vaflags, struct ucred *cred)
{
        struct vnode *vp;
        dirfs_mount_t dmp;
        int error = 0;
        int flags;
        char *tmp;
        char *pathfree;

        vp = NODE_TO_VP(dnp);
        dmp = VFS_TO_DIRFS(vp->v_mount);

        KKASSERT(vn_islocked(vp));

        flags = dnp->dn_flags;

        error = vop_helper_setattr_flags(&flags, vaflags, dnp->dn_uid, cred);
        /*
         * When running vkernels with non-root it is not possible to set
         * certain flags on host files, such as SF* flags. chflags(2) call
         * will spit an error in that case.
         */
        if (error == 0) {
                tmp = dirfs_node_absolute_path(dmp, dnp, &pathfree);
                KKASSERT(tmp);
                if((lchflags(tmp, flags)) == -1)
                        error = errno;
                dirfs_node_stat(DIRFS_NOFD, tmp, dnp);
                dirfs_dropfd(dmp, NULL, pathfree);
        }

        KKASSERT(vn_islocked(vp));

        return error;
}

int
dirfs_node_chmod(dirfs_mount_t dmp, dirfs_node_t dnp, mode_t mode)
{
        char *tmp;
        char *pathfree;
        int error = 0;

        tmp = dirfs_node_absolute_path(dmp, dnp, &pathfree);
        KKASSERT(tmp);
        if (lchmod(tmp, mode) < 0)
                error = errno;
        dirfs_node_stat(DIRFS_NOFD, tmp, dnp);
        dirfs_dropfd(dmp, NULL, pathfree);

        return error;
}

int
dirfs_node_chown(dirfs_mount_t dmp, dirfs_node_t dnp,
                 uid_t uid, uid_t gid, mode_t mode)
{
        char *tmp;
        char *pathfree;
        int error = 0;

        tmp = dirfs_node_absolute_path(dmp, dnp, &pathfree);
        KKASSERT(tmp);
        if (lchown(tmp, uid, gid) < 0)
                error = errno;
        if (mode != dnp->dn_mode)
                lchmod(tmp, mode);
        dirfs_node_stat(DIRFS_NOFD, tmp, dnp);
        dirfs_dropfd(dmp, NULL, pathfree);

        return error;
}


int
dirfs_node_chsize(dirfs_node_t dnp, off_t nsize)
{
        dirfs_mount_t dmp;
        struct vnode *vp;
        int error = 0;
        char *tmp;
        char *pathfree;
        off_t osize;
        int biosize;

        KKASSERT(dnp);

        vp = NODE_TO_VP(dnp);
        dmp = VFS_TO_DIRFS(vp->v_mount);
        biosize = BSIZE;
        osize = dnp->dn_size;

        KKASSERT(vn_islocked(vp));

        switch (vp->v_type) {
        case VDIR:
                return (EISDIR);
        case VREG:
                break;
        default:
                return (EOPNOTSUPP);

        }

        tmp = dirfs_node_absolute_path(dmp, dnp, &pathfree);
        if (nsize < osize) {
                error = nvtruncbuf(vp, nsize, biosize, -1, 0);
        } else {
                error = nvextendbuf(vp, osize, nsize,
                                    biosize, biosize,
                                    -1, -1, 0);
        }
        if (error == 0 && truncate(tmp, nsize) < 0)
                error = errno;
        if (error == 0)
                dnp->dn_size = nsize;
        dbg(9, "TRUNCATE %016jx %016jx\n", (intmax_t)nsize, dnp->dn_size);
        /*dirfs_node_stat(DIRFS_NOFD, tmp, dnp); don't need to do this*/

        dirfs_dropfd(dmp, NULL, pathfree);


        KKASSERT(vn_islocked(vp));

        return error;
}

void
dirfs_node_setpassive(dirfs_mount_t dmp, dirfs_node_t dnp, int state)
{
        struct vnode *vp;

        dbg(5, "dnp=%p state=%d dnp->dn_fd=%d\n", dnp, state, dnp->dn_fd);

        if (state && (dnp->dn_state & DIRFS_PASVFD) == 0 &&
            dnp->dn_fd != DIRFS_NOFD) {
                dirfs_node_ref(dnp);
                dirfs_node_setflags(dnp, DIRFS_PASVFD);
                TAILQ_INSERT_TAIL(&dmp->dm_fdlist, dnp, dn_fdentry);
                ++dirfs_fd_used;
                ++dmp->dm_fd_used;

                /*
                 * If we are over our limit remove nodes from the
                 * passive fd cache.
                 */
                while (dmp->dm_fd_used > dirfs_fd_limit) {
                        dnp = TAILQ_FIRST(&dmp->dm_fdlist);
                        dirfs_node_setpassive(dmp, dnp, 0);
                }
        }
        if (state == 0 && (dnp->dn_state & DIRFS_PASVFD)) {
                dirfs_node_clrflags(dnp, DIRFS_PASVFD);
                TAILQ_REMOVE(&dmp->dm_fdlist, dnp, dn_fdentry);
                --dirfs_fd_used;
                --dmp->dm_fd_used;
                dbg(5, "dnp=%p removed from fdlist. %d used refs=%d\n",
                    dnp, dirfs_fd_used, dirfs_node_refcnt(dnp));

                /*
                 * Attempt to close the descriptor.  We can only do this
                 * if the related vnode is inactive and has exactly two
                 * refs (representing the vp<->dnp and PASVFD).  Otherwise
                 * someone might have ref'd the node in order to use the
                 * dn_fd.
                 *
                 * Also, if the vnode is in any way dirty we leave the fd
                 * open for the buffer cache code.  The syncer will eventually
                 * come along and fsync the vnode, and the next inactive
                 * transition will deal with the descriptor.
                 *
                 * The descriptor for the root node is NEVER closed by
                 * this function.
                 */
                vp = dnp->dn_vnode;
                if (dirfs_node_refcnt(dnp) == 2 && vp &&
                    dnp->dn_fd != DIRFS_NOFD &&
                    !dirfs_node_isroot(dnp) &&
                    (vp->v_flag & (VINACTIVE|VOBJDIRTY)) == VINACTIVE &&
                    RB_EMPTY(&vp->v_rbdirty_tree))
                {
                        dbg(9, "passive cache: closing %d\n", dnp->dn_fd);
                        close(dnp->dn_fd);
                        dnp->dn_fd = DIRFS_NOFD;
                } else {
                        if (dirfs_node_refcnt(dnp) == 1 && dnp->dn_vnode == NULL &&
                            dnp->dn_fd != DIRFS_NOFD &&
                            dnp != dmp->dm_root) {
                                dbg(9, "passive cache: closing %d\n", dnp->dn_fd);
                                close(dnp->dn_fd);
                                dnp->dn_fd = DIRFS_NOFD;
                        }
                }
                dirfs_node_drop(dmp, dnp);
        }
}

char *
dirfs_flag2str(dirfs_node_t dnp)
{
        const char *txtflg[] = { DIRFS_TXTFLG };
        static char str[512] = {0};

        if (dnp->dn_state & DIRFS_PASVFD)
                ksprintf(str, "%s ", txtflg[0]);

        return str;
}

void
debug(int level, const char *fmt, ...)
{
        __va_list ap;

        if (debuglvl >= level) {
                __va_start(ap, fmt);
                kvprintf(fmt, ap);
                __va_end(ap);
        }
}