/*-
 * Copyright (c) 1992, 1993, 1994, 1995 Jan-Simon Pendry.
 * Copyright (c) 1992, 1993, 1994, 1995
 *      The Regents of the University of California.
 * Copyright (c) 2005, 2006 Masanori Ozawa <ozawa@ongs.co.jp>, ONGS Inc.
 * Copyright (c) 2006 Daichi Goto <daichi@freebsd.org>
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Jan-Simon Pendry.
 *
 * 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.
 * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.
 *
 *      @(#)union_vnops.c       8.32 (Berkeley) 6/23/95
 * $FreeBSD: src/sys/fs/unionfs/union_vnops.c,v 1.152 2008/01/13 14:44:06 attilio Exp $
 *
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/kernel.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/mount.h>
#include <sys/mutex.h>
#include <sys/namei.h>
#include <sys/sysctl.h>
#include <sys/vnode.h>
#include <sys/buf.h>
#include <sys/fcntl.h>
#include <sys/stat.h>
#include <sys/dirent.h>
#include <sys/proc.h>

#include <fs/unionfs/unionfs.h>
#include <miscfs/genfs/genfs.h>
#include <miscfs/specfs/specdev.h>

#if 0
#define UNIONFS_INTERNAL_DEBUG(msg, args...)    printf(msg, ## args)
#define UNIONFS_IDBG_RENAME
#else
#define UNIONFS_INTERNAL_DEBUG(msg, args...)
#endif

static int
unionfs_parsepath(void *v)
{
        struct vop_parsepath_args /* {
                struct vnode *a_dvp;
                const char *a_name;
                size_t *a_retval;
        } */ *ap = v;
        struct unionfs_node *dunp;
        struct vnode *upperdvp, *lowerdvp;
        size_t upper, lower;
        int error;

        dunp = VTOUNIONFS(ap->a_dvp);
        upperdvp = dunp->un_uppervp;
        lowerdvp = dunp->un_lowervp;

        error = VOP_PARSEPATH(upperdvp, ap->a_name, &upper);
        if (error) {
                return error;
        }

        error = VOP_PARSEPATH(lowerdvp, ap->a_name, &lower);
        if (error) {
                return error;
        }

        /*
         * If they're different, use the larger one. This is not a
         * comprehensive solution, but it's sufficient for the
         * non-default cases of parsepath that currently exist.
         */
        *ap->a_retval = MAX(upper, lower);
        return 0;
}

static int
unionfs_lookup(void *v)
{
        struct vop_lookup_v2_args /* {
                struct vnodeop_desc *a_desc;
                struct vnode *a_dvp;
                struct vnode **a_vpp;
                struct componentname *a_cnp;
        } */ *ap = v;
        int             iswhiteout;
        int             error , uerror, lerror;
        u_long          nameiop;
        u_long          cnflags, cnflagsbk;
        struct unionfs_node *dunp;
        struct vnode   *dvp, *udvp, *ldvp, *vp, *uvp, *lvp, *dtmpvp;
        struct vattr    va;
        struct componentname *cnp;

        iswhiteout = 0;
        error = uerror = lerror = ENOENT;
        cnp = ap->a_cnp;
        nameiop = cnp->cn_nameiop;
        cnflags = cnp->cn_flags;
        dvp = ap->a_dvp;
        dunp = VTOUNIONFS(dvp);
        udvp = dunp->un_uppervp;
        ldvp = dunp->un_lowervp;
        vp = uvp = lvp = NULLVP;
        *(ap->a_vpp) = NULLVP;

        UNIONFS_INTERNAL_DEBUG("unionfs_lookup: enter: nameiop=%ld, flags=%lx, path=%s\n", nameiop, cnflags, cnp->cn_nameptr);

        if (dvp->v_type != VDIR)
                return (ENOTDIR);

        /*
         * If read-only and op is not LOOKUP, will return EROFS.
         */
        if ((cnflags & ISLASTCN) &&
            (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
            LOOKUP != nameiop)
                return (EROFS);

        /*
         * lookup dotdot
         */
        if (cnflags & ISDOTDOT) {
                if (LOOKUP != nameiop && udvp == NULLVP)
                        return (EROFS);

                if (udvp != NULLVP) {
                        dtmpvp = udvp;
                        if (ldvp != NULLVP)
                                VOP_UNLOCK(ldvp);
                }
                else
                        dtmpvp = ldvp;

                error = VOP_LOOKUP(dtmpvp, &vp, cnp);

                if (dtmpvp == udvp && ldvp != NULLVP) {
                        VOP_UNLOCK(udvp);
                        vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
                }

                if (error == 0) {
                        /*
                         * Exchange lock and reference from vp to
                         * dunp->un_dvp. vp is upper/lower vnode, but it
                         * will need to return the unionfs vnode.
                         */
                        if (nameiop == DELETE  || nameiop == RENAME)
                                VOP_UNLOCK(vp);
                        vrele(vp);

                        VOP_UNLOCK(dvp);
                        *(ap->a_vpp) = dunp->un_dvp;
                        vref(dunp->un_dvp);

                        vn_lock(dunp->un_dvp, LK_EXCLUSIVE | LK_RETRY);
                        vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
                } else if (error == ENOENT && nameiop != CREATE)
                        cache_enter(dvp, NULLVP, cnp->cn_nameptr,
                                    cnp->cn_namelen, cnp->cn_flags);

                UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", error);

                return (error);
        }

        /*
         * lookup upper layer
         */
        if (udvp != NULLVP) {
                uerror = VOP_LOOKUP(udvp, &uvp, cnp);

                if (uerror == 0) {
                        if (udvp == uvp) {      /* is dot */
                                vrele(uvp);
                                *(ap->a_vpp) = dvp;
                                vref(dvp);

                                UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", uerror);

                                return (uerror);
                        }
                }

                /* check whiteout */
                if (uerror == ENOENT || uerror == EJUSTRETURN)
                        if (cnp->cn_flags & ISWHITEOUT)
                                iswhiteout = 1; /* don't lookup lower */
                if (iswhiteout == 0 && ldvp != NULLVP)
                        if (VOP_GETATTR(udvp, &va, cnp->cn_cred) == 0 &&
                            (va.va_flags & OPAQUE))
                                iswhiteout = 1; /* don't lookup lower */
#if 0
                UNIONFS_INTERNAL_DEBUG("unionfs_lookup: debug: whiteout=%d, path=%s\n", iswhiteout, cnp->cn_nameptr);
#endif
        }

        /*
         * lookup lower layer
         */
        if (ldvp != NULLVP && !(cnflags & DOWHITEOUT) && iswhiteout == 0) {
                /* always op is LOOKUP */
                cnp->cn_nameiop = LOOKUP;
                cnflagsbk = cnp->cn_flags;
                cnp->cn_flags = cnflags;

                lerror = VOP_LOOKUP(ldvp, &lvp, cnp);

                cnp->cn_nameiop = nameiop;
                if (udvp != NULLVP && (uerror == 0 || uerror == EJUSTRETURN))
                        cnp->cn_flags = cnflagsbk;

                if (lerror == 0) {
                        if (ldvp == lvp) {      /* is dot */
                                if (uvp != NULLVP)
                                        vrele(uvp);     /* no need? */
                                vrele(lvp);
                                *(ap->a_vpp) = dvp;
                                vref(dvp);

                                UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", lerror);
                                if (uvp != NULL)
                                        VOP_UNLOCK(uvp);
                                return (lerror);
                        }
                }
        }

        /*
         * check lookup result
         */
        if (uvp == NULLVP && lvp == NULLVP) {
                UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n",
                    (udvp != NULLVP ? uerror : lerror));
                return (udvp != NULLVP ? uerror : lerror);
        }

        /*
         * check vnode type
         */
        if (uvp != NULLVP && lvp != NULLVP && uvp->v_type != lvp->v_type) {
                vput(lvp);
                lvp = NULLVP;
        }

        /*
         * check shadow dir
         */
        if (uerror != 0 && uerror != EJUSTRETURN && udvp != NULLVP &&
            lerror == 0 && lvp != NULLVP && lvp->v_type == VDIR &&
            !(dvp->v_mount->mnt_flag & MNT_RDONLY) &&
            (1 < cnp->cn_namelen || '.' != *(cnp->cn_nameptr))) {
                /* get unionfs vnode in order to create a new shadow dir. */
                error = unionfs_nodeget(dvp->v_mount, NULLVP, lvp, dvp, &vp,
                    cnp);
                if (error != 0)
                        goto unionfs_lookup_out;
                error = unionfs_mkshadowdir(MOUNTTOUNIONFSMOUNT(dvp->v_mount),
                    udvp, VTOUNIONFS(vp), cnp);
                if (error != 0) {
                        UNIONFSDEBUG("unionfs_lookup: Unable to create shadow dir.");
                        vput(vp);
                        goto unionfs_lookup_out;
                }
        }
        /*
         * get unionfs vnode.
         */
        else {
                if (uvp != NULLVP)
                        error = uerror;
                else
                        error = lerror;
                if (error != 0)
                        goto unionfs_lookup_out;
                error = unionfs_nodeget(dvp->v_mount, uvp, lvp, dvp, &vp, cnp);
                if (error != 0) {
                        UNIONFSDEBUG("unionfs_lookup: Unable to create unionfs vnode.");
                        goto unionfs_lookup_out;
                }
        }

        *(ap->a_vpp) = vp;

        cache_enter(dvp, vp, cnp->cn_nameptr, cnp->cn_namelen,
                    cnp->cn_flags);

        /* XXXAD lock status on error */
unionfs_lookup_out:
        if (uvp != NULLVP)
                vrele(uvp);
        if (lvp != NULLVP)
                vrele(lvp);

        if (error == ENOENT && nameiop != CREATE)
                cache_enter(dvp, NULLVP, cnp->cn_nameptr, cnp->cn_namelen,
                            cnp->cn_flags);

        UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", error);

        return (error);
}

static int
unionfs_create(void *v)
{
        struct vop_create_v3_args /* {
                struct vnode *a_dvp;
                struct vnode **a_vpp;
                struct componentname *a_cnp;
                struct vattr *a_vap;
        } */ *ap = v;
        struct unionfs_node *dunp;
        struct componentname *cnp;
        struct vnode   *udvp;
        struct vnode   *vp;
        int             error;

        UNIONFS_INTERNAL_DEBUG("unionfs_create: enter\n");

        dunp = VTOUNIONFS(ap->a_dvp);
        cnp = ap->a_cnp;
        udvp = dunp->un_uppervp;
        error = EROFS;

        if (udvp != NULLVP) {
                if ((error = VOP_CREATE(udvp, &vp, cnp, ap->a_vap)) == 0) {
                        error = unionfs_nodeget(ap->a_dvp->v_mount, vp, NULLVP,
                            ap->a_dvp, ap->a_vpp, cnp);
                        if (error) {
                                vput(vp);
                        } else {
                                vrele(vp);
                        }
                }
        }

        UNIONFS_INTERNAL_DEBUG("unionfs_create: leave (%d)\n", error);

        return (error);
}

static int
unionfs_whiteout(void *v)
{
        struct vop_whiteout_args *ap = v;
        struct unionfs_node *dunp;
        struct componentname *cnp;
        struct vnode   *udvp;
        int             error;

        UNIONFS_INTERNAL_DEBUG("unionfs_whiteout: enter\n");

        dunp = VTOUNIONFS(ap->a_dvp);
        cnp = ap->a_cnp;
        udvp = dunp->un_uppervp;
        error = EOPNOTSUPP;

        if (udvp != NULLVP) {
                switch (ap->a_flags) {
                case CREATE:
                case DELETE:
                case LOOKUP:
                        error = VOP_WHITEOUT(udvp, cnp, ap->a_flags);
                        break;
                default:
                        error = EINVAL;
                        break;
                }
        }

        UNIONFS_INTERNAL_DEBUG("unionfs_whiteout: leave (%d)\n", error);

        return (error);
}

static int
unionfs_mknod(void *v)
{
        struct vop_mknod_v3_args /* {
                struct vnode *a_dvp;
                struct vnode **a_vpp;
                struct componentname *a_cnp;
                struct vattr *a_vap;
        } */ *ap = v;
        struct unionfs_node *dunp;
        struct componentname *cnp;
        struct vnode   *udvp;
        struct vnode   *vp;
        int             error;

        UNIONFS_INTERNAL_DEBUG("unionfs_mknod: enter\n");

        dunp = VTOUNIONFS(ap->a_dvp);
        cnp = ap->a_cnp;
        udvp = dunp->un_uppervp;
        error = EROFS;

        if (udvp != NULLVP) {
                if ((error = VOP_MKNOD(udvp, &vp, cnp, ap->a_vap)) == 0) {
                        error = unionfs_nodeget(ap->a_dvp->v_mount, vp, NULLVP,
                            ap->a_dvp, ap->a_vpp, cnp);
                        if (error) {
                                vput(vp);
                        } else {
                                vrele(vp);
                        }
                }
        }

        UNIONFS_INTERNAL_DEBUG("unionfs_mknod: leave (%d)\n", error);

        return (error);
}

static int
unionfs_open(void *v)
{
        struct vop_open_args *ap = v;
        int             error;
        struct unionfs_node *unp;
        struct unionfs_node_status *unsp;
        struct vnode   *uvp;
        struct vnode   *lvp;
        struct vnode   *targetvp;
        kauth_cred_t   cred;

        UNIONFS_INTERNAL_DEBUG("unionfs_open: enter\n");

        error = 0;
        unp = VTOUNIONFS(ap->a_vp);
        uvp = unp->un_uppervp;
        lvp = unp->un_lowervp;
        targetvp = NULLVP;
        cred = ap->a_cred;

        unionfs_get_node_status(unp, &unsp);

        if (unsp->uns_lower_opencnt > 0 || unsp->uns_upper_opencnt > 0) {
                /* vnode is already opend. */
                if (unsp->uns_upper_opencnt > 0)
                        targetvp = uvp;
                else
                        targetvp = lvp;

                if (targetvp == lvp &&
                    (ap->a_mode & FWRITE) && lvp->v_type == VREG)
                        targetvp = NULLVP;
        }
        if (targetvp == NULLVP) {
                if (uvp == NULLVP) {
                        if ((ap->a_mode & FWRITE) && lvp->v_type == VREG) {
                                error = unionfs_copyfile(unp,
                                    !(ap->a_mode & O_TRUNC), cred);
                                if (error != 0)
                                        goto unionfs_open_abort;
                                targetvp = uvp = unp->un_uppervp;
                        } else
                                targetvp = lvp;
                } else
                        targetvp = uvp;
        }

        error = VOP_OPEN(targetvp, ap->a_mode, cred);
        if (error == 0) {
                if (targetvp == uvp) {
                        if (uvp->v_type == VDIR && lvp != NULLVP &&
                            unsp->uns_lower_opencnt <= 0) {
                                /* open lower for readdir */
                                error = VOP_OPEN(lvp, FREAD, cred);
                                if (error != 0) {
                                        VOP_CLOSE(uvp, ap->a_mode, cred);
                                        goto unionfs_open_abort;
                                }
                                unsp->uns_node_flag |= UNS_OPENL_4_READDIR;
                                unsp->uns_lower_opencnt++;
                        }
                        unsp->uns_upper_opencnt++;
                } else {
                        unsp->uns_lower_opencnt++;
                        unsp->uns_lower_openmode = ap->a_mode;
                }
        }

unionfs_open_abort:
        if (error != 0)
                unionfs_tryrem_node_status(unp, unsp);

        UNIONFS_INTERNAL_DEBUG("unionfs_open: leave (%d)\n", error);

        return (error);
}

static int
unionfs_close(void *v)
{
        struct vop_close_args *ap = v;
        int             error;
        struct unionfs_node *unp;
        struct unionfs_node_status *unsp;
        kauth_cred_t   cred;
        struct vnode   *ovp;

        UNIONFS_INTERNAL_DEBUG("unionfs_close: enter\n");

        KASSERT(VOP_ISLOCKED(ap->a_vp) == LK_EXCLUSIVE);
        unp = VTOUNIONFS(ap->a_vp);
        cred = ap->a_cred;

        unionfs_get_node_status(unp, &unsp);

        if (unsp->uns_lower_opencnt <= 0 && unsp->uns_upper_opencnt <= 0) {
#ifdef DIAGNOSTIC
                printf("unionfs_close: warning: open count is 0\n");
#endif
                if (unp->un_uppervp != NULLVP)
                        ovp = unp->un_uppervp;
                else
                        ovp = unp->un_lowervp;
        } else if (unsp->uns_upper_opencnt > 0)
                ovp = unp->un_uppervp;
        else
                ovp = unp->un_lowervp;

        error = VOP_CLOSE(ovp, ap->a_fflag, cred);

        if (error != 0)
                goto unionfs_close_abort;

        if (ovp == unp->un_uppervp) {
                unsp->uns_upper_opencnt--;
                if (unsp->uns_upper_opencnt == 0) {
                        if (unsp->uns_node_flag & UNS_OPENL_4_READDIR) {
                                VOP_CLOSE(unp->un_lowervp, FREAD, cred);
                                unsp->uns_node_flag &= ~UNS_OPENL_4_READDIR;
                                unsp->uns_lower_opencnt--;
                        }
                }
        } else
                unsp->uns_lower_opencnt--;

unionfs_close_abort:
        unionfs_tryrem_node_status(unp, unsp);

        UNIONFS_INTERNAL_DEBUG("unionfs_close: leave (%d)\n", error);

        return (error);
}

/*
 * Check the access mode toward shadow file/dir.
 */
static int
unionfs_check_corrected_access(u_short mode, struct vattr *va, kauth_cred_t cred)
{
        uid_t           uid;    /* upper side vnode's uid */
        gid_t           gid;    /* upper side vnode's gid */
        u_short         vmode;  /* upper side vnode's mode */
        u_short         mask;

        mask = 0;
        uid = va->va_uid;
        gid = va->va_gid;
        vmode = va->va_mode;

        /* check owner */
        if (kauth_cred_getuid(cred) == uid) {
                if (mode & VEXEC)
                        mask |= S_IXUSR;
                if (mode & VREAD)
                        mask |= S_IRUSR;
                if (mode & VWRITE)
                        mask |= S_IWUSR;
                return ((vmode & mask) == mask ? 0 : EACCES);
        }

        /* check group */
        if (kauth_cred_groupmember(cred, gid) == 0) {
                if (mode & VEXEC)
                        mask |= S_IXGRP;
                if (mode & VREAD)
                        mask |= S_IRGRP;
                if (mode & VWRITE)
                        mask |= S_IWGRP;
                return ((vmode & mask) == mask ? 0 : EACCES);
        }

        /* check other */
        if (mode & VEXEC)
                mask |= S_IXOTH;
        if (mode & VREAD)
                mask |= S_IROTH;
        if (mode & VWRITE)
                mask |= S_IWOTH;

        return ((vmode & mask) == mask ? 0 : EACCES);
}

static int
unionfs_access(void *v)
{       
        struct vop_access_args /* {
                struct vnodeop_desc *a_desc;
                struct vnode *a_vp;
                accmode_t a_accmode;
                kauth_cred_t a_cred;
        } */ *ap = v;
        struct unionfs_mount *ump;
        struct unionfs_node *unp;
        struct vnode   *uvp;
        struct vnode   *lvp;
        struct vattr    va;
        int             accmode;
        int             error;

        UNIONFS_INTERNAL_DEBUG("unionfs_access: enter\n");

        ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount);
        unp = VTOUNIONFS(ap->a_vp);
        uvp = unp->un_uppervp;
        lvp = unp->un_lowervp;
        accmode = ap->a_accmode;
        error = EACCES;

        if ((accmode & VWRITE) &&
            (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)) {
                switch (ap->a_vp->v_type) {
                case VREG:
                case VDIR:
                case VLNK:
                        return (EROFS);
                default:
                        break;
                }
        }

        if (uvp != NULLVP) {
                error = VOP_ACCESS(uvp, accmode, ap->a_cred);

                UNIONFS_INTERNAL_DEBUG("unionfs_access: leave (%d)\n", error);

                return (error);
        }

        if (lvp != NULLVP) {
                if (accmode & VWRITE) {
                        if (ump->um_uppervp->v_mount->mnt_flag & MNT_RDONLY) {
                                switch (ap->a_vp->v_type) {
                                case VREG:
                                case VDIR:
                                case VLNK:
                                        return (EROFS);
                                default:
                                        break;
                                }
                        } else if (ap->a_vp->v_type == VREG || ap->a_vp->v_type == VDIR) {
                                /* check shadow file/dir */
                                if (ump->um_copymode != UNIONFS_TRANSPARENT) {
                                        error = unionfs_create_uppervattr(ump,
                                            lvp, &va, ap->a_cred);
                                        if (error != 0)
                                                return (error);

                                        error = unionfs_check_corrected_access(
                                            accmode, &va, ap->a_cred);
                                        if (error != 0)
                                                return (error);
                                }
                        }
                        accmode &= ~VWRITE;
                        accmode |= VREAD; /* will copy to upper */
                }
                error = VOP_ACCESS(lvp, accmode, ap->a_cred);
        }

        UNIONFS_INTERNAL_DEBUG("unionfs_access: leave (%d)\n", error);

        return (error);
}

static int
unionfs_getattr(void *v)
{
        struct vop_getattr_args *ap = v;
        int             error;
        struct unionfs_node *unp;
        struct unionfs_mount *ump;
        struct vnode   *uvp;
        struct vnode   *lvp;
        struct vattr    va;

        UNIONFS_INTERNAL_DEBUG("unionfs_getattr: enter\n");

        unp = VTOUNIONFS(ap->a_vp);
        ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount);
        uvp = unp->un_uppervp;
        lvp = unp->un_lowervp;

        if (uvp != NULLVP) {
                if ((error = VOP_GETATTR(uvp, ap->a_vap, ap->a_cred)) == 0)
                        ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid;

                UNIONFS_INTERNAL_DEBUG("unionfs_getattr: leave mode=%o, uid=%d, gid=%d (%d)\n",
                    ap->a_vap->va_mode, ap->a_vap->va_uid,
                    ap->a_vap->va_gid, error);

                return (error);
        }

        error = VOP_GETATTR(lvp, ap->a_vap, ap->a_cred);

        if (error == 0 && !(ump->um_uppervp->v_mount->mnt_flag & MNT_RDONLY)) {
                /* correct the attr toward shadow file/dir. */
                if (ap->a_vp->v_type == VREG || ap->a_vp->v_type == VDIR) {
                        unionfs_create_uppervattr_core(ump, ap->a_vap, &va);
                        ap->a_vap->va_mode = va.va_mode;
                        ap->a_vap->va_uid = va.va_uid;
                        ap->a_vap->va_gid = va.va_gid;
                }
        }

        if (error == 0)
                ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid;

        UNIONFS_INTERNAL_DEBUG("unionfs_getattr: leave mode=%o, uid=%d, gid=%d (%d)\n",
            ap->a_vap->va_mode, ap->a_vap->va_uid, ap->a_vap->va_gid, error);

        return (error);
}

static int
unionfs_setattr(void *v)
{
        struct vop_setattr_args /* {
                struct vnode *a_vp;
                struct vattr *a_vap;
                kauth_cred_t a_cred;
        } */ *ap = v;
        int             error;
        struct unionfs_node *unp;
        struct vnode   *uvp;
        struct vnode   *lvp;
        struct vattr   *vap;

        UNIONFS_INTERNAL_DEBUG("unionfs_setattr: enter\n");

        error = EROFS;
        unp = VTOUNIONFS(ap->a_vp);
        uvp = unp->un_uppervp;
        lvp = unp->un_lowervp;
        vap = ap->a_vap;

        if ((ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) &&
            (vap->va_flags != (unsigned long )VNOVAL ||
             vap->va_uid != (uid_t)VNOVAL ||
             vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
             vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL))
                return (EROFS);

        if (uvp == NULLVP && lvp->v_type == VREG) {
                error = unionfs_copyfile(unp, (vap->va_size != 0),
                    ap->a_cred);
                if (error != 0)
                        return (error);
                uvp = unp->un_uppervp;
        }

        if (uvp != NULLVP)
                error = VOP_SETATTR(uvp, vap, ap->a_cred);

        UNIONFS_INTERNAL_DEBUG("unionfs_setattr: leave (%d)\n", error);

        return (error);
}

static int
unionfs_read(void *v)
{
        struct vop_read_args *ap = v;
        int             error;
        struct unionfs_node *unp;
        struct vnode   *tvp;

        /* UNIONFS_INTERNAL_DEBUG("unionfs_read: enter\n"); */

        unp = VTOUNIONFS(ap->a_vp);
        tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);

        error = VOP_READ(tvp, ap->a_uio, ap->a_ioflag, ap->a_cred);

        /* UNIONFS_INTERNAL_DEBUG("unionfs_read: leave (%d)\n", error); */

        return (error);
}

static int
unionfs_write(void *v)
{
        struct vop_write_args *ap = v;
        int             error;
        struct unionfs_node *unp;
        struct vnode   *tvp;

        /* UNIONFS_INTERNAL_DEBUG("unionfs_write: enter\n"); */

        unp = VTOUNIONFS(ap->a_vp);
        tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);

        error = VOP_WRITE(tvp, ap->a_uio, ap->a_ioflag, ap->a_cred);

        /* UNIONFS_INTERNAL_DEBUG("unionfs_write: leave (%d)\n", error); */

        return (error);
}

static int
unionfs_ioctl(void *v)
{
        struct vop_ioctl_args *ap = v;
        int error;
        struct unionfs_node *unp;
        struct unionfs_node_status *unsp;
        struct vnode   *ovp;

        UNIONFS_INTERNAL_DEBUG("unionfs_ioctl: enter\n");

        vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
        unp = VTOUNIONFS(ap->a_vp);
        unionfs_get_node_status(unp, &unsp);
        ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp);
        unionfs_tryrem_node_status(unp, unsp);
        VOP_UNLOCK(ap->a_vp);

        if (ovp == NULLVP)
                return (EBADF);

        error = VOP_IOCTL(ovp, ap->a_command, ap->a_data, ap->a_fflag,
            ap->a_cred);

        UNIONFS_INTERNAL_DEBUG("unionfs_ioctl: lease (%d)\n", error);

        return (error);
}

static int
unionfs_poll(void *v)
{
        struct vop_poll_args *ap = v;
        struct unionfs_node *unp;
        struct unionfs_node_status *unsp;
        struct vnode   *ovp;

        vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
        unp = VTOUNIONFS(ap->a_vp);
        unionfs_get_node_status(unp, &unsp);
        ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp);
        unionfs_tryrem_node_status(unp, unsp);
        VOP_UNLOCK(ap->a_vp);

        if (ovp == NULLVP)
                return (EBADF);

        return (VOP_POLL(ovp, ap->a_events));
}

static int
unionfs_fsync(void *v)
{
        struct vop_fsync_args *ap = v;
        struct unionfs_node *unp;
        struct unionfs_node_status *unsp;
        struct vnode   *ovp;

        unp = VTOUNIONFS(ap->a_vp);
        unionfs_get_node_status(unp, &unsp);
        ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp);
        unionfs_tryrem_node_status(unp, unsp);

        if (ovp == NULLVP)
                return (EBADF);

        return (VOP_FSYNC(ovp, ap->a_cred, ap->a_flags, ap->a_offlo, ap->a_offhi));
}

static int
unionfs_remove(void *v)
{
        struct vop_remove_v3_args *ap = v;
        int             error;
        struct unionfs_node *dunp;
        struct unionfs_node *unp;
        struct unionfs_mount *ump;
        struct vnode   *udvp;
        struct vnode   *uvp;
        struct vnode   *lvp;
        struct componentname *cnp;

        UNIONFS_INTERNAL_DEBUG("unionfs_remove: enter\n");

        error = 0;
        dunp = VTOUNIONFS(ap->a_dvp);
        unp = VTOUNIONFS(ap->a_vp);
        udvp = dunp->un_uppervp;
        uvp = unp->un_uppervp;
        lvp = unp->un_lowervp;
        cnp = ap->a_cnp;

        if (udvp == NULLVP) {
                vput(ap->a_vp);
                return (EROFS);
        }

        if (uvp != NULLVP) {
                ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount);
                if (ump->um_whitemode == UNIONFS_WHITE_ALWAYS || lvp != NULLVP)
                        cnp->cn_flags |= DOWHITEOUT;
                error = VOP_REMOVE(udvp, uvp, cnp);
        } else if (lvp != NULLVP)
                error = unionfs_mkwhiteout(udvp, cnp, unp->un_path);

        UNIONFS_INTERNAL_DEBUG("unionfs_remove: leave (%d)\n", error);

        return (error);
}

static int
unionfs_link(void *v)
{
#if 0
        struct vop_link_v2_args *ap = v;
        int             error;
        int             needrelookup;
        struct unionfs_node *dunp;
        struct unionfs_node *unp;
        struct vnode   *udvp;
        struct vnode   *uvp;
        struct componentname *cnp;

        UNIONFS_INTERNAL_DEBUG("unionfs_link: enter\n");

        error = 0;
        needrelookup = 0;
        dunp = VTOUNIONFS(ap->a_tdvp);
        unp = NULL;
        udvp = dunp->un_uppervp;
        uvp = NULLVP;
        cnp = ap->a_cnp;

        if (udvp == NULLVP)
                return (EROFS);

        if (ap->a_vp->v_op != unionfs_vnodeop_p)
                uvp = ap->a_vp;
        else {
                unp = VTOUNIONFS(ap->a_vp);

                if (unp->un_uppervp == NULLVP) {
                        if (ap->a_vp->v_type != VREG)
                                return (EOPNOTSUPP);

                        error = unionfs_copyfile(unp, 1, cnp->cn_cred);
                        if (error != 0)
                                return (error);
                        needrelookup = 1;
                }
                uvp = unp->un_uppervp;
        }

        if (needrelookup != 0)
                error = unionfs_relookup_for_create(ap->a_tdvp, cnp);

        if (error == 0)
                error = VOP_LINK(udvp, uvp, cnp);

        UNIONFS_INTERNAL_DEBUG("unionfs_link: leave (%d)\n", error);

        return (error);
#else
        panic("XXXAD");
        return 0;
#endif
}

static int
unionfs_rename(void *v)
{
        struct vop_rename_args *ap = v;
        int             error;
        struct vnode   *fdvp;
        struct vnode   *fvp;
        struct componentname *fcnp;
        struct vnode   *tdvp;
        struct vnode   *tvp;
        struct componentname *tcnp;
        struct vnode   *ltdvp;
        struct vnode   *ltvp;

        /* rename target vnodes */
        struct vnode   *rfdvp;
        struct vnode   *rfvp;
        struct vnode   *rtdvp;
        struct vnode   *rtvp;

        int             needrelookup;
        struct unionfs_mount *ump;
        struct unionfs_node *unp;

        UNIONFS_INTERNAL_DEBUG("unionfs_rename: enter\n");

        error = 0;
        fdvp = ap->a_fdvp;
        fvp = ap->a_fvp;
        fcnp = ap->a_fcnp;
        tdvp = ap->a_tdvp;
        tvp = ap->a_tvp;
        tcnp = ap->a_tcnp;
        ltdvp = NULLVP;
        ltvp = NULLVP;
        rfdvp = fdvp;
        rfvp = fvp;
        rtdvp = tdvp;
        rtvp = tvp;
        needrelookup = 0;

        /* check for cross device rename */
        if (fvp->v_mount != tdvp->v_mount ||
            (tvp != NULLVP && fvp->v_mount != tvp->v_mount)) {
                error = EXDEV;
                goto unionfs_rename_abort;
        }

        /* Renaming a file to itself has no effect. */
        if (fvp == tvp)
                goto unionfs_rename_abort;

        /*
         * from/to vnode is unionfs node.
         */

        unp = VTOUNIONFS(fdvp);
#ifdef UNIONFS_IDBG_RENAME
        UNIONFS_INTERNAL_DEBUG("fdvp=%p, ufdvp=%p, lfdvp=%p\n", fdvp, unp->un_uppervp, unp->un_lowervp);
#endif
        if (unp->un_uppervp == NULLVP) {
                error = ENODEV;
                goto unionfs_rename_abort;
        }
        rfdvp = unp->un_uppervp;
        vref(rfdvp);

        unp = VTOUNIONFS(fvp);
#ifdef UNIONFS_IDBG_RENAME
        UNIONFS_INTERNAL_DEBUG("fvp=%p, ufvp=%p, lfvp=%p\n", fvp, unp->un_uppervp, unp->un_lowervp);
#endif
        ump = MOUNTTOUNIONFSMOUNT(fvp->v_mount);
        if (unp->un_uppervp == NULLVP) {
                switch (fvp->v_type) {
                case VREG:
                        if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
                                goto unionfs_rename_abort;
                        error = unionfs_copyfile(unp, 1, fcnp->cn_cred);
                        VOP_UNLOCK(fvp);
                        if (error != 0)
                                goto unionfs_rename_abort;
                        break;
                case VDIR:
                        if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
                                goto unionfs_rename_abort;
                        error = unionfs_mkshadowdir(ump, rfdvp, unp, fcnp);
                        VOP_UNLOCK(fvp);
                        if (error != 0)
                                goto unionfs_rename_abort;
                        break;
                default:
                        error = ENODEV;
                        goto unionfs_rename_abort;
                }

                needrelookup = 1;
        }

        if (unp->un_lowervp != NULLVP)
                fcnp->cn_flags |= DOWHITEOUT;
        rfvp = unp->un_uppervp;
        vref(rfvp);

        unp = VTOUNIONFS(tdvp);
#ifdef UNIONFS_IDBG_RENAME
        UNIONFS_INTERNAL_DEBUG("tdvp=%p, utdvp=%p, ltdvp=%p\n", tdvp, unp->un_uppervp, unp->un_lowervp);
#endif
        if (unp->un_uppervp == NULLVP) {
                error = ENODEV;
                goto unionfs_rename_abort;
        }
        rtdvp = unp->un_uppervp;
        ltdvp = unp->un_lowervp;
        vref(rtdvp);

        if (tdvp == tvp) {
                rtvp = rtdvp;
                vref(rtvp);
        } else if (tvp != NULLVP) {
                unp = VTOUNIONFS(tvp);
#ifdef UNIONFS_IDBG_RENAME
                UNIONFS_INTERNAL_DEBUG("tvp=%p, utvp=%p, ltvp=%p\n", tvp, unp->un_uppervp, unp->un_lowervp);
#endif
                if (unp->un_uppervp == NULLVP)
                        rtvp = NULLVP;
                else {
                        if (tvp->v_type == VDIR) {
                                error = EINVAL;
                                goto unionfs_rename_abort;
                        }
                        rtvp = unp->un_uppervp;
                        ltvp = unp->un_lowervp;
                        vref(rtvp);
                }
        }

        if (needrelookup != 0) {
                if ((error = vn_lock(fdvp, LK_EXCLUSIVE)) != 0)
                        goto unionfs_rename_abort;
                error = unionfs_relookup_for_delete(fdvp, fcnp);
                VOP_UNLOCK(fdvp);
                if (error != 0)
                        goto unionfs_rename_abort;

                /* Locke of tvp is canceled in order to avoid recursive lock. */
                if (tvp != NULLVP && tvp != tdvp)
                        VOP_UNLOCK(tvp);
                error = unionfs_relookup_for_rename(tdvp, tcnp);
                if (tvp != NULLVP && tvp != tdvp)
                        vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY);
                if (error != 0)
                        goto unionfs_rename_abort;
        }

        error = VOP_RENAME(rfdvp, rfvp, fcnp, rtdvp, rtvp, tcnp);

        if (error == 0) {
                if (rtvp != NULLVP && rtvp->v_type == VDIR)
                        cache_purge(tdvp);
                if (fvp->v_type == VDIR && fdvp != tdvp)
                        cache_purge(fdvp);
        }

        if (fdvp != rfdvp)
                vrele(fdvp);
        if (fvp != rfvp)
                vrele(fvp);
        if (ltdvp != NULLVP)
                VOP_UNLOCK(ltdvp);
        if (tdvp != rtdvp)
                vrele(tdvp);
        if (ltvp != NULLVP)
                VOP_UNLOCK(ltvp);
        if (tvp != rtvp && tvp != NULLVP) {
                if (rtvp == NULLVP)
                        vput(tvp);
                else
                        vrele(tvp);
        }

        UNIONFS_INTERNAL_DEBUG("unionfs_rename: leave (%d)\n", error);

        return (error);

unionfs_rename_abort:
        if (fdvp != rfdvp)
                vrele(rfdvp);
        if (fvp != rfvp)
                vrele(rfvp);
        if (tdvp != rtdvp)
                vrele(rtdvp);
        vput(tdvp);
        if (tvp != rtvp && rtvp != NULLVP)
                vrele(rtvp);
        if (tvp != NULLVP) {
                if (tdvp != tvp)
                        vput(tvp);
                else
                        vrele(tvp);
        }
        vrele(fdvp);
        vrele(fvp);

        UNIONFS_INTERNAL_DEBUG("unionfs_rename: leave (%d)\n", error);

        return (error);
}

static int
unionfs_mkdir(void *v)
{
        struct vop_mkdir_v3_args /* {
                struct vnode *a_dvp;
                struct vnode **a_vpp;
                struct componentname *a_cnp;
                struct vattr *a_vap;
        } */ *ap = v;
        int             error;
        struct unionfs_node *dunp;
        struct componentname *cnp;
        struct vnode   *udvp;
        struct vnode   *uvp;
        struct vattr    va;

        UNIONFS_INTERNAL_DEBUG("unionfs_mkdir: enter\n");

        error = EROFS;
        dunp = VTOUNIONFS(ap->a_dvp);
        cnp = ap->a_cnp;
        udvp = dunp->un_uppervp;

        if (udvp != NULLVP) {
                /* check opaque */
                if (!(cnp->cn_flags & ISWHITEOUT)) {
                        error = VOP_GETATTR(udvp, &va, cnp->cn_cred);
                        if (error != 0)
                                return (error);
                        if (va.va_flags & OPAQUE) 
                                cnp->cn_flags |= ISWHITEOUT;
                }

                if ((error = VOP_MKDIR(udvp, &uvp, cnp, ap->a_vap)) == 0) {
                        error = unionfs_nodeget(ap->a_dvp->v_mount, uvp, NULLVP,
                            ap->a_dvp, ap->a_vpp, cnp);
                        if (error) {
                                vput(uvp);
                        } else {
                                vrele(uvp);
                        }
                }
        }

        UNIONFS_INTERNAL_DEBUG("unionfs_mkdir: leave (%d)\n", error);

        return (error);
}

static int
unionfs_rmdir(void *v)
{
        struct vop_rmdir_v2_args *ap = v;
        int             error;
        struct unionfs_node *dunp;
        struct unionfs_node *unp;
        struct unionfs_mount *ump;
        struct componentname *cnp;
        struct vnode   *udvp;
        struct vnode   *uvp;
        struct vnode   *lvp;

        UNIONFS_INTERNAL_DEBUG("unionfs_rmdir: enter\n");

        error = 0;
        dunp = VTOUNIONFS(ap->a_dvp);
        unp = VTOUNIONFS(ap->a_vp);
        cnp = ap->a_cnp;
        udvp = dunp->un_uppervp;
        uvp = unp->un_uppervp;
        lvp = unp->un_lowervp;

        if (udvp == NULLVP) {
                vput(ap->a_vp);
                return (EROFS);
        }

        if (udvp == uvp)
                return (EOPNOTSUPP);

        if (uvp != NULLVP) {
                if (lvp != NULLVP) {
                        error = unionfs_check_rmdir(ap->a_vp, cnp->cn_cred);
                        if (error != 0)
                                return (error);
                }
                ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount);
                if (ump->um_whitemode == UNIONFS_WHITE_ALWAYS || lvp != NULLVP)
                        cnp->cn_flags |= DOWHITEOUT;
                error = VOP_RMDIR(udvp, uvp, cnp);
        }
        else if (lvp != NULLVP)
                error = unionfs_mkwhiteout(udvp, cnp, unp->un_path);

        if (error == 0) {
                cache_purge(ap->a_dvp);
                cache_purge(ap->a_vp);
        }

        UNIONFS_INTERNAL_DEBUG("unionfs_rmdir: leave (%d)\n", error);

        return (error);
}

static int
unionfs_symlink(void *v)
{
        struct vop_symlink_v3_args /* {
                struct vnode *a_dvp;
                struct vnode **a_vpp;
                struct componentname *a_cnp;
                struct vattr *a_vap;
                char *a_target;
        } */ *ap = v;
        int             error;
        struct unionfs_node *dunp;
        struct componentname *cnp;
        struct vnode   *udvp;
        struct vnode   *uvp;

        UNIONFS_INTERNAL_DEBUG("unionfs_symlink: enter\n");

        error = EROFS;
        dunp = VTOUNIONFS(ap->a_dvp);
        cnp = ap->a_cnp;
        udvp = dunp->un_uppervp;

        if (udvp != NULLVP) {
                error = VOP_SYMLINK(udvp, &uvp, cnp, ap->a_vap, ap->a_target);
                if (error == 0) {
                        error = unionfs_nodeget(ap->a_dvp->v_mount, uvp, NULLVP,
                            ap->a_dvp, ap->a_vpp, cnp);
                        if (error) {
                                vput(uvp);
                        } else {
                                vrele(uvp);
                        }
                }
        }

        UNIONFS_INTERNAL_DEBUG("unionfs_symlink: leave (%d)\n", error);

        return (error);
}

static int
unionfs_readdir(void *v)
{
        struct vop_readdir_args *ap = v;
        int             error;
        int             eofflag;
        struct unionfs_node *unp;
        struct unionfs_node_status *unsp;
        struct uio     *uio;
        struct vnode   *uvp;
        struct vnode   *lvp;
        struct vattr    va;

        int             ncookies_bk;
        off_t          *cookies_bk;

        UNIONFS_INTERNAL_DEBUG("unionfs_readdir: enter\n");

        error = 0;
        eofflag = 0;
        unp = VTOUNIONFS(ap->a_vp);
        uio = ap->a_uio;
        uvp = unp->un_uppervp;
        lvp = unp->un_lowervp;
        ncookies_bk = 0;
        cookies_bk = NULL;

        if (ap->a_vp->v_type != VDIR)
                return (ENOTDIR);

        /* check opaque */
        if (uvp != NULLVP && lvp != NULLVP) {
                if ((error = VOP_GETATTR(uvp, &va, ap->a_cred)) != 0)
                        goto unionfs_readdir_exit;
                if (va.va_flags & OPAQUE)
                        lvp = NULLVP;
        }

        /* check the open count. unionfs needs to open before readdir. */
        VOP_UNLOCK(ap->a_vp);
        vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
        unionfs_get_node_status(unp, &unsp);
        if ((uvp != NULLVP && unsp->uns_upper_opencnt <= 0) ||
            (lvp != NULLVP && unsp->uns_lower_opencnt <= 0)) {
                unionfs_tryrem_node_status(unp, unsp);
                error = EBADF;
        }
        if (error != 0)
                goto unionfs_readdir_exit;

        /* upper only */
        if (uvp != NULLVP && lvp == NULLVP) {
                error = VOP_READDIR(uvp, uio, ap->a_cred, ap->a_eofflag,
                    ap->a_cookies, ap->a_ncookies);
                unsp->uns_readdir_status = 0;

                goto unionfs_readdir_exit;
        }

        /* lower only */
        if (uvp == NULLVP && lvp != NULLVP) {
                error = VOP_READDIR(lvp, uio, ap->a_cred, ap->a_eofflag,
                    ap->a_cookies, ap->a_ncookies);
                unsp->uns_readdir_status = 2;

                goto unionfs_readdir_exit;
        }

        /*
         * readdir upper and lower
         */
        KASSERT(uvp != NULLVP);
        KASSERT(lvp != NULLVP);
        if (uio->uio_offset == 0)
                unsp->uns_readdir_status = 0;

        if (unsp->uns_readdir_status == 0) {
                /* read upper */
                error = VOP_READDIR(uvp, uio, ap->a_cred, &eofflag,
                                    ap->a_cookies, ap->a_ncookies);

                if (error != 0 || eofflag == 0)
                        goto unionfs_readdir_exit;
                unsp->uns_readdir_status = 1;

                /*
                 * ufs(and other fs) needs size of uio_resid larger than
                 * DIRBLKSIZ.
                 * size of DIRBLKSIZ equals DEV_BSIZE.
                 * (see: ufs/ufs/ufs_vnops.c ufs_readdir func , ufs/ufs/dir.h)
                 */
                if (uio->uio_resid <= (uio->uio_resid & (DEV_BSIZE -1)))
                        goto unionfs_readdir_exit;

                /*
                 * backup cookies
                 * It prepares to readdir in lower.
                 */
                if (ap->a_ncookies != NULL) {
                        ncookies_bk = *(ap->a_ncookies);
                        *(ap->a_ncookies) = 0;
                }
                if (ap->a_cookies != NULL) {
                        cookies_bk = *(ap->a_cookies);
                        *(ap->a_cookies) = NULL;
                }
        }

        /* initialize for readdir in lower */
        if (unsp->uns_readdir_status == 1) {
                unsp->uns_readdir_status = 2;
                uio->uio_offset = 0;
        }

        if (lvp == NULLVP) {
                error = EBADF;
                goto unionfs_readdir_exit;
        }
        /* read lower */
        error = VOP_READDIR(lvp, uio, ap->a_cred, ap->a_eofflag,
                            ap->a_cookies, ap->a_ncookies);

        if (cookies_bk != NULL) {
                /* merge cookies */
                int             size;
                off_t         *newcookies, *pos;

                size = *(ap->a_ncookies) + ncookies_bk;
                newcookies = (off_t *) malloc(size * sizeof(off_t),
                    M_TEMP, M_WAITOK);
                pos = newcookies;

                memcpy(pos, cookies_bk, ncookies_bk * sizeof(off_t));
                pos += ncookies_bk * sizeof(off_t);
                memcpy(pos, *(ap->a_cookies), *(ap->a_ncookies) * sizeof(off_t));
                free(cookies_bk, M_TEMP);
                free(*(ap->a_cookies), M_TEMP);
                *(ap->a_ncookies) = size;
                *(ap->a_cookies) = newcookies;
        }

unionfs_readdir_exit:
        if (error != 0 && ap->a_eofflag != NULL)
                *(ap->a_eofflag) = 1;

        UNIONFS_INTERNAL_DEBUG("unionfs_readdir: leave (%d)\n", error);

        return (error);
}

static int
unionfs_readlink(void *v)
{
        struct vop_readlink_args *ap = v;
        int error;
        struct unionfs_node *unp;
        struct vnode   *vp;

        UNIONFS_INTERNAL_DEBUG("unionfs_readlink: enter\n");

        unp = VTOUNIONFS(ap->a_vp);
        vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);

        error = VOP_READLINK(vp, ap->a_uio, ap->a_cred);

        UNIONFS_INTERNAL_DEBUG("unionfs_readlink: leave (%d)\n", error);

        return (error);
}

static int
unionfs_inactive(void *v)
{
        struct vop_inactive_v2_args *ap = v;
        *ap->a_recycle = true;
        return (0);
}

static int
unionfs_reclaim(void *v)
{
        struct vop_reclaim_v2_args *ap = v;

        /* UNIONFS_INTERNAL_DEBUG("unionfs_reclaim: enter\n"); */

        VOP_UNLOCK(ap->a_vp);

        unionfs_noderem(ap->a_vp);

        /* UNIONFS_INTERNAL_DEBUG("unionfs_reclaim: leave\n"); */

        return (0);
}

static int
unionfs_print(void *v)
{
        struct vop_print_args *ap = v;
        struct unionfs_node *unp;
        /* struct unionfs_node_status *unsp; */

        unp = VTOUNIONFS(ap->a_vp);
        /* unionfs_get_node_status(unp, &unsp); */

        printf("unionfs_vp=%p, uppervp=%p, lowervp=%p\n",
            ap->a_vp, unp->un_uppervp, unp->un_lowervp);
        /*
        printf("unionfs opencnt: uppervp=%d, lowervp=%d\n",
            unsp->uns_upper_opencnt, unsp->uns_lower_opencnt);
        */

        if (unp->un_uppervp != NULLVP)
                vprint("unionfs: upper", unp->un_uppervp);
        if (unp->un_lowervp != NULLVP)
                vprint("unionfs: lower", unp->un_lowervp);

        return (0);
}

static int
unionfs_lock(void *v)
{
        struct vop_lock_args *ap = v;
        int             error;
        int             flags;
        struct vnode   *lvp;
        struct vnode   *uvp;
        struct unionfs_node *unp;

        unp = VTOUNIONFS(ap->a_vp);
        lvp = unp->un_lowervp;
        uvp = unp->un_uppervp;
        flags = ap->a_flags;
        error = 0;

        if (lvp != NULLVP) {
                error = VOP_LOCK(lvp, flags);
        }
        if (error == 0 && uvp != NULLVP) {
                error = VOP_LOCK(uvp, flags);
                if (error != 0) {
                        VOP_UNLOCK(lvp);
                }
        }

        return error;
}

static int
unionfs_unlock(void *v)
{
        struct vop_unlock_args *ap = v;
        int             error;
        struct vnode   *lvp;
        struct vnode   *uvp;
        struct unionfs_node *unp;

        unp = VTOUNIONFS(ap->a_vp);
        lvp = unp->un_lowervp;
        uvp = unp->un_uppervp;
        error = 0;

        if (lvp != NULLVP) {
                error = VOP_UNLOCK(lvp);
        }
        if (error == 0 && uvp != NULLVP) {
                error = VOP_UNLOCK(uvp);
        }

        return error;
}

static int
unionfs_pathconf(void *v)
{
        struct vop_pathconf_args *ap = v;
        struct unionfs_node *unp;
        struct vnode   *vp;

        unp = VTOUNIONFS(ap->a_vp);
        vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);

        return (VOP_PATHCONF(vp, ap->a_name, ap->a_retval));
}

static int
unionfs_advlock(void *v)
{
        struct vop_advlock_args *ap = v;
        int error;
        struct unionfs_node *unp;
        struct unionfs_node_status *unsp;
        struct vnode   *vp;
        struct vnode   *uvp;
        kauth_cred_t    cred;

        UNIONFS_INTERNAL_DEBUG("unionfs_advlock: enter\n");

        vp = ap->a_vp;
        cred = kauth_cred_get();

        vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);

        unp = VTOUNIONFS(ap->a_vp);
        uvp = unp->un_uppervp;

        if (uvp == NULLVP) {
                error = unionfs_copyfile(unp, 1, cred);
                if (error != 0)
                        goto unionfs_advlock_abort;
                uvp = unp->un_uppervp;

                unionfs_get_node_status(unp, &unsp);
                if (unsp->uns_lower_opencnt > 0) {
                        /* try reopen the vnode */
                        error = VOP_OPEN(uvp, unsp->uns_lower_openmode, cred);
                        if (error)
                                goto unionfs_advlock_abort;
                        unsp->uns_upper_opencnt++;
                        VOP_CLOSE(unp->un_lowervp, unsp->uns_lower_openmode, cred);
                        unsp->uns_lower_opencnt--;
                } else
                        unionfs_tryrem_node_status(unp, unsp);
        }

        VOP_UNLOCK(vp);

        error = VOP_ADVLOCK(uvp, ap->a_id, ap->a_op, ap->a_fl, ap->a_flags);

        UNIONFS_INTERNAL_DEBUG("unionfs_advlock: leave (%d)\n", error);

        return error;

unionfs_advlock_abort:
        VOP_UNLOCK(vp);

        UNIONFS_INTERNAL_DEBUG("unionfs_advlock: leave (%d)\n", error);

        return error;
}

static int
unionfs_strategy(void *v)
{
        struct vop_strategy_args *ap = v;
        struct unionfs_node *unp;
        struct vnode   *vp;

        unp = VTOUNIONFS(ap->a_vp);
        vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);

#ifdef DIAGNOSTIC
        if (vp == NULLVP)
                panic("unionfs_strategy: nullvp");
        if ((ap->a_bp->b_flags & B_READ) == 0 && vp == unp->un_lowervp)
                panic("unionfs_strategy: writing to lowervp");
#endif

        return (VOP_STRATEGY(vp, ap->a_bp));
}

static int
unionfs_kqfilter(void *v)
{
        struct vop_kqfilter_args *ap = v;
        struct unionfs_node *unp;
        struct vnode   *tvp;

        unp = VTOUNIONFS(ap->a_vp);
        tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);

        return VOP_KQFILTER(tvp, ap->a_kn);
}

static int
unionfs_bmap(void *v)
{
        struct vop_bmap_args *ap = v;
        struct unionfs_node *unp;
        struct vnode   *tvp;

        unp = VTOUNIONFS(ap->a_vp);
        tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);

        return VOP_BMAP(tvp, ap->a_bn, ap->a_vpp, ap->a_bnp, ap->a_runp);
}

static int
unionfs_mmap(void *v)
{
        struct vop_mmap_args *ap = v;
        struct unionfs_node *unp;
        struct vnode   *tvp;

        unp = VTOUNIONFS(ap->a_vp);
        tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);

        return VOP_MMAP(tvp, ap->a_prot, ap->a_cred);
}

static int
unionfs_abortop(void *v)
{
        struct vop_abortop_args *ap = v;
        struct unionfs_node *unp;
        struct vnode   *tvp;

        unp = VTOUNIONFS(ap->a_dvp);
        tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);

        return VOP_ABORTOP(tvp, ap->a_cnp);
}

static int
unionfs_islocked(void *v)
{
        struct vop_islocked_args *ap = v;
        struct unionfs_node *unp;
        struct vnode   *tvp;

        unp = VTOUNIONFS(ap->a_vp);
        tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);

        return VOP_ISLOCKED(tvp);
}

static int
unionfs_seek(void *v)
{
        struct vop_seek_args *ap = v;
        struct unionfs_node *unp;
        struct vnode   *tvp;

        unp = VTOUNIONFS(ap->a_vp);
        tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);

        return VOP_SEEK(tvp, ap->a_oldoff, ap->a_newoff, ap->a_cred);
}

static int
unionfs_putpages(void *v)
{
        struct vop_putpages_args /* {
                struct vnode *a_vp;
                voff_t a_offlo;
                voff_t a_offhi;
                int a_flags;
        } */ *ap = v;
        struct vnode *vp = ap->a_vp, *tvp;
        struct unionfs_node *unp;

        KASSERT(rw_lock_held(vp->v_uobj.vmobjlock));

        unp = VTOUNIONFS(vp);
        tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
        KASSERT(tvp->v_uobj.vmobjlock == vp->v_uobj.vmobjlock);

        if (ap->a_flags & PGO_RECLAIM) {
                rw_exit(vp->v_uobj.vmobjlock);
                return 0;
        }
        return VOP_PUTPAGES(tvp, ap->a_offlo, ap->a_offhi, ap->a_flags);
}

static int
unionfs_getpages(void *v)
{
        struct vop_getpages_args /* {
                struct vnode *a_vp;
                voff_t a_offset;
                struct vm_page **a_m;
                int *a_count;
                int a_centeridx;
                vm_prot_t a_access_type;
                int a_advice;
                int a_flags;
        } */ *ap = v;
        struct vnode *vp = ap->a_vp, *tvp;
        struct unionfs_node *unp;

        KASSERT(rw_lock_held(vp->v_uobj.vmobjlock));

        unp = VTOUNIONFS(vp);
        tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
        KASSERT(tvp->v_uobj.vmobjlock == vp->v_uobj.vmobjlock);

        if (ap->a_flags & PGO_LOCKED) {
                return EBUSY;
        }
        return VOP_GETPAGES(tvp, ap->a_offset, ap->a_m, ap->a_count,
            ap->a_centeridx, ap->a_access_type, ap->a_advice, ap->a_flags);
}

static int
unionfs_revoke(void *v)
{
        struct vop_revoke_args *ap = v;
        struct unionfs_node *unp;
        struct vnode   *tvp;
        int error;

        unp = VTOUNIONFS(ap->a_vp);
        tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);

        error = VOP_REVOKE(tvp, ap->a_flags);
        if (error == 0) {
                vgone(ap->a_vp);        /* ??? */
        }
        return error;
}

/*
 * Global vfs data structures
 */
int (**unionfs_vnodeop_p)(void *);
const struct vnodeopv_entry_desc unionfs_vnodeop_entries[] = {
        { &vop_default_desc, vn_default_error },
        { &vop_parsepath_desc, unionfs_parsepath },     /* parsepath */
        { &vop_lookup_desc, unionfs_lookup },           /* lookup */
        { &vop_create_desc, unionfs_create },           /* create */
        { &vop_whiteout_desc, unionfs_whiteout },       /* whiteout */
        { &vop_mknod_desc, unionfs_mknod },             /* mknod */
        { &vop_open_desc, unionfs_open },               /* open */
        { &vop_close_desc, unionfs_close },             /* close */
        { &vop_access_desc, unionfs_access },           /* access */
        { &vop_accessx_desc, genfs_accessx },           /* accessx */
        { &vop_getattr_desc, unionfs_getattr },         /* getattr */
        { &vop_setattr_desc, unionfs_setattr },         /* setattr */
        { &vop_read_desc, unionfs_read },               /* read */
        { &vop_write_desc, unionfs_write },             /* write */
        { &vop_fallocate_desc, genfs_eopnotsupp },      /* fallocate */
        { &vop_fdiscard_desc, genfs_eopnotsupp },       /* fdiscard */
        { &vop_ioctl_desc, unionfs_ioctl },             /* ioctl */
        { &vop_poll_desc, unionfs_poll },               /* select */
        { &vop_revoke_desc, unionfs_revoke },           /* revoke */
        { &vop_mmap_desc, unionfs_mmap },               /* mmap */
        { &vop_fsync_desc, unionfs_fsync },             /* fsync */
        { &vop_seek_desc, unionfs_seek },               /* seek */
        { &vop_remove_desc, unionfs_remove },           /* remove */
        { &vop_link_desc, unionfs_link },               /* link */
        { &vop_rename_desc, unionfs_rename },           /* rename */
        { &vop_mkdir_desc, unionfs_mkdir },             /* mkdir */
        { &vop_rmdir_desc, unionfs_rmdir },             /* rmdir */
        { &vop_symlink_desc, unionfs_symlink },         /* symlink */
        { &vop_readdir_desc, unionfs_readdir },         /* readdir */
        { &vop_readlink_desc, unionfs_readlink },       /* readlink */
        { &vop_abortop_desc, unionfs_abortop },         /* abortop */
        { &vop_inactive_desc, unionfs_inactive },       /* inactive */
        { &vop_reclaim_desc, unionfs_reclaim },         /* reclaim */
        { &vop_lock_desc, unionfs_lock },               /* lock */
        { &vop_unlock_desc, unionfs_unlock },           /* unlock */
        { &vop_bmap_desc, unionfs_bmap },               /* bmap */
        { &vop_strategy_desc, unionfs_strategy },       /* strategy */
        { &vop_print_desc, unionfs_print },             /* print */
        { &vop_islocked_desc, unionfs_islocked },       /* islocked */
        { &vop_pathconf_desc, unionfs_pathconf },       /* pathconf */
        { &vop_advlock_desc, unionfs_advlock },         /* advlock */
        { &vop_getpages_desc, unionfs_getpages },       /* getpages */
        { &vop_putpages_desc, unionfs_putpages },       /* putpages */
        { &vop_kqfilter_desc, unionfs_kqfilter },       /* kqfilter */
#ifdef notdef
        { &vop_bwrite_desc, unionfs_bwrite },           /* bwrite */
#endif
        { NULL, NULL }
};
const struct vnodeopv_desc unionfs_vnodeop_opv_desc =
        { &unionfs_vnodeop_p, unionfs_vnodeop_entries };