/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/file.h>
#include <sys/types.h>
#include <sys/pathname.h>
#include <sys/proc.h>
#include <sys/mode.h>
#include <sys/vnode.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunldi.h>
#include <sys/uio.h>
#include <sys/attr.h>
#include <sys/acl.h>
#include <sys/fs/zut.h>

ldi_ident_t zut_li = NULL;
dev_info_t *zut_dip;

static int
zut_open_dir(char *path, vnode_t *startvp, cred_t *cr, int flags,
    pathname_t *realpn, vnode_t **dvn)
{
        pathname_t pn;
        vnode_t *vp;
        vnode_t *rootvp;
        proc_t *p = curproc;
        int error;

        pn_alloc(&pn);
        (void) strlcpy(pn.pn_buf, path, MAXPATHLEN);
        pn.pn_pathlen = strlen(path);

        mutex_enter(&p->p_lock);        /* for u_rdir and u_cdir */
        if ((rootvp = PTOU(p)->u_rdir) == NULL)
                rootvp = rootdir;
        else if (rootvp != rootdir)     /* no need to VN_HOLD rootdir */
                VN_HOLD(rootvp);

        if (pn.pn_path[0] == '/') {
                vp = rootvp;
        } else {
                vp = (startvp == NULL) ? PTOU(p)->u_cdir : startvp;
        }
        VN_HOLD(vp);
        mutex_exit(&p->p_lock);

        /*
         * Skip over leading slashes
         */
        while (pn.pn_path[0] == '/') {
                pn.pn_path++;
                pn.pn_pathlen--;
        }

        error = lookuppnvp(&pn, realpn, flags | FOLLOW, NULL,
            dvn, rootvp, vp, cr);

        /*
         * If we lack read access to the directory, we should error out.
         */
        if (!error) {
                if (vfs_has_feature((*dvn)->v_vfsp, VFSFT_ACEMASKONACCESS)) {
                        error = VOP_ACCESS(*dvn, ACE_LIST_DIRECTORY,
                            V_ACE_MASK, cr, NULL);
                } else {
                        error = VOP_ACCESS(*dvn, VREAD, 0, cr, NULL);
                }
        }

        pn_free(&pn);

        return (error);
}

static int
zut_readdir(intptr_t arg, cred_t *cr, int iflag, int *rvalp)
{
        zut_readdir_t *zr;
        struct iovec aiov;
        struct uio auio;
        vnode_t *dvn = NULL;
        vnode_t *fvn = NULL;
        char *kbuf;
        int flags = 0;
        int error, rc;

        zr = kmem_zalloc(sizeof (zut_readdir_t), KM_SLEEP);
        error = ddi_copyin((void *)arg, zr, sizeof (zut_readdir_t), iflag);
        if (error)
                goto zutr_bail;

        kbuf = kmem_zalloc(zr->zr_buflen, KM_SLEEP);

        zr->zr_retcode = zut_open_dir(zr->zr_dir, NULL, cr, flags, NULL, &dvn);
        if (zr->zr_retcode)
                goto zutr_done;

        if (zr->zr_reqflags & ZUT_XATTR) {
                vattr_t vattr;

                zr->zr_retcode = VOP_LOOKUP(dvn, zr->zr_file, &fvn,
                    NULL, flags, NULL, cr, NULL, NULL, NULL);
                VN_RELE(dvn);
                dvn = NULL;
                if (zr->zr_retcode)
                        goto zutr_done;

                /*
                 * In order to access hidden attribute directory the
                 * user must have appropriate read access and be able
                 * to stat() the file
                 */
                if (vfs_has_feature(fvn->v_vfsp, VFSFT_ACEMASKONACCESS)) {
                        zr->zr_retcode = VOP_ACCESS(fvn, ACE_READ_NAMED_ATTRS,
                            V_ACE_MASK, cr, NULL);
                } else {
                        zr->zr_retcode = VOP_ACCESS(fvn, VREAD, 0, cr, NULL);
                }
                if (zr->zr_retcode)
                        goto zutr_done;

                vattr.va_mask = AT_ALL;
                zr->zr_retcode = VOP_GETATTR(fvn, &vattr, 0, cr, NULL);
                if (zr->zr_retcode)
                        goto zutr_done;

                zr->zr_retcode = VOP_LOOKUP(fvn, "", &dvn, NULL,
                    flags | LOOKUP_XATTR, NULL, cr, NULL, NULL, NULL);
                VN_RELE(fvn);
                if (zr->zr_retcode)
                        goto zutr_done;
        }

        aiov.iov_base = kbuf;
        aiov.iov_len = zr->zr_buflen;
        auio.uio_iov = &aiov;
        auio.uio_iovcnt = 1;
        auio.uio_loffset = zr->zr_loffset;
        auio.uio_segflg = UIO_SYSSPACE;
        auio.uio_resid = zr->zr_buflen;
        auio.uio_fmode = 0;
        auio.uio_extflg = UIO_COPY_CACHED;

        if (zr->zr_reqflags & ZUT_EXTRDDIR)
                flags |= V_RDDIR_ENTFLAGS;
        if (zr->zr_reqflags & ZUT_ACCFILTER)
                flags |= V_RDDIR_ACCFILTER;

        (void) VOP_RWLOCK(dvn, V_WRITELOCK_FALSE, NULL);
        zr->zr_retcode = VOP_READDIR(dvn, &auio, cr, &zr->zr_eof,
            NULL, flags);
        VOP_RWUNLOCK(dvn, V_WRITELOCK_FALSE, NULL);
        VN_RELE(dvn);

        zr->zr_bytes = aiov.iov_base - kbuf;
        zr->zr_loffset = auio.uio_loffset;

        error = ddi_copyout(kbuf, (void *)(uintptr_t)zr->zr_buf,
            zr->zr_buflen, iflag);

zutr_done:
        kmem_free(kbuf, zr->zr_buflen);
        rc = ddi_copyout(zr, (void *)arg, sizeof (zut_readdir_t), iflag);
        if (error == 0)
                error = rc;

zutr_bail:
        kmem_free(zr, sizeof (zut_readdir_t));
        if (rvalp)
                *rvalp = error;
        return (error);
}

static int
zut_stat64(vnode_t *vp, struct stat64 *sb, uint64_t *xvs, int flag, cred_t *cr)
{
        xoptattr_t *xoap = NULL;
        xvattr_t xv = { 0 };
        int error;

        xva_init(&xv);

        XVA_SET_REQ(&xv, XAT_ARCHIVE);
        XVA_SET_REQ(&xv, XAT_SYSTEM);
        XVA_SET_REQ(&xv, XAT_READONLY);
        XVA_SET_REQ(&xv, XAT_HIDDEN);
        XVA_SET_REQ(&xv, XAT_NOUNLINK);
        XVA_SET_REQ(&xv, XAT_IMMUTABLE);
        XVA_SET_REQ(&xv, XAT_APPENDONLY);
        XVA_SET_REQ(&xv, XAT_NODUMP);
        XVA_SET_REQ(&xv, XAT_OPAQUE);
        XVA_SET_REQ(&xv, XAT_AV_QUARANTINED);
        XVA_SET_REQ(&xv, XAT_AV_MODIFIED);
        XVA_SET_REQ(&xv, XAT_REPARSE);
        XVA_SET_REQ(&xv, XAT_OFFLINE);
        XVA_SET_REQ(&xv, XAT_SPARSE);

        xv.xva_vattr.va_mask |= AT_STAT | AT_NBLOCKS | AT_BLKSIZE | AT_SIZE;
        if (error = VOP_GETATTR(vp, &xv.xva_vattr, flag, cr, NULL))
                return (error);

        bzero(sb, sizeof (sb));
        sb->st_dev = xv.xva_vattr.va_fsid;
        sb->st_ino = xv.xva_vattr.va_nodeid;
        sb->st_mode = VTTOIF(xv.xva_vattr.va_type) | xv.xva_vattr.va_mode;
        sb->st_nlink = xv.xva_vattr.va_nlink;
        sb->st_uid = xv.xva_vattr.va_uid;
        sb->st_gid = xv.xva_vattr.va_gid;
        sb->st_rdev = xv.xva_vattr.va_rdev;
        sb->st_size = xv.xva_vattr.va_size;
        sb->st_atim = xv.xva_vattr.va_atime;
        sb->st_mtim = xv.xva_vattr.va_mtime;
        sb->st_ctim = xv.xva_vattr.va_ctime;
        sb->st_blksize = xv.xva_vattr.va_blksize;
        sb->st_blocks = xv.xva_vattr.va_nblocks;
        sb->st_fstype[0] = 0;

        if ((xoap = xva_getxoptattr(&xv)) == NULL)
                return (0);

        if (XVA_ISSET_RTN(&xv, XAT_ARCHIVE) && xoap->xoa_archive)
                *xvs |= (1 << F_ARCHIVE);
        if (XVA_ISSET_RTN(&xv, XAT_SYSTEM) && xoap->xoa_system)
                *xvs |= (1 << F_SYSTEM);
        if (XVA_ISSET_RTN(&xv, XAT_READONLY) && xoap->xoa_readonly)
                *xvs |= (1 << F_READONLY);
        if (XVA_ISSET_RTN(&xv, XAT_HIDDEN) && xoap->xoa_hidden)
                *xvs |= (1 << F_HIDDEN);
        if (XVA_ISSET_RTN(&xv, XAT_NOUNLINK) && xoap->xoa_nounlink)
                *xvs |= (1 << F_NOUNLINK);
        if (XVA_ISSET_RTN(&xv, XAT_IMMUTABLE) && xoap->xoa_immutable)
                *xvs |= (1 << F_IMMUTABLE);
        if (XVA_ISSET_RTN(&xv, XAT_APPENDONLY) && xoap->xoa_appendonly)
                *xvs |= (1 << F_APPENDONLY);
        if (XVA_ISSET_RTN(&xv, XAT_NODUMP) && xoap->xoa_nodump)
                *xvs |= (1 << F_NODUMP);
        if (XVA_ISSET_RTN(&xv, XAT_OPAQUE) && xoap->xoa_opaque)
                *xvs |= (1 << F_OPAQUE);
        if (XVA_ISSET_RTN(&xv, XAT_AV_QUARANTINED) && xoap->xoa_av_quarantined)
                *xvs |= (1 << F_AV_QUARANTINED);
        if (XVA_ISSET_RTN(&xv, XAT_AV_MODIFIED) && xoap->xoa_av_modified)
                *xvs |= (1 << F_AV_MODIFIED);
        if (XVA_ISSET_RTN(&xv, XAT_REPARSE) && xoap->xoa_reparse)
                *xvs |= (1 << F_REPARSE);
        if (XVA_ISSET_RTN(&xv, XAT_OFFLINE) && xoap->xoa_offline)
                *xvs |= (1 << F_OFFLINE);
        if (XVA_ISSET_RTN(&xv, XAT_SPARSE) && xoap->xoa_sparse)
                *xvs |= (1 << F_SPARSE);

        return (0);
}

/*ARGSUSED*/
static int
zut_lookup(intptr_t arg, cred_t *cr, int iflag, int *rvalp)
{
        zut_lookup_t *zl;
        pathname_t rpn;
        vnode_t *dvn = NULL;
        vnode_t *fvn = NULL;
        vnode_t *xdvn = NULL;
        vnode_t *xfvn = NULL;
        vnode_t *release = NULL;
        int flags = 0;
        int error, rc;

        zl = kmem_zalloc(sizeof (zut_lookup_t), KM_SLEEP);

        error = ddi_copyin((void *)arg, zl, sizeof (zut_lookup_t), iflag);
        if (error)
                goto zutl_bail;

        pn_alloc(&rpn);
        bzero(rpn.pn_buf, MAXPATHLEN);

        zl->zl_retcode = zut_open_dir(zl->zl_dir, NULL, cr, flags, &rpn, &dvn);
        if (zl->zl_retcode)
                goto zutl_done;

        if (zl->zl_reqflags & ZUT_IGNORECASE)
                flags |= FIGNORECASE;

        zl->zl_retcode = VOP_LOOKUP(dvn, zl->zl_file, &fvn, NULL, flags, NULL,
            cr, NULL, &zl->zl_deflags, &rpn);
        if (zl->zl_retcode)
                goto zutl_done;

        release = fvn;

        if (zl->zl_reqflags & ZUT_XATTR) {
                vattr_t vattr;

                /*
                 * In order to access hidden attribute directory the
                 * user must have appropriate read access and be able
                 * to stat() the file
                 */
                if (vfs_has_feature(fvn->v_vfsp, VFSFT_ACEMASKONACCESS)) {
                        zl->zl_retcode = VOP_ACCESS(fvn, ACE_READ_NAMED_ATTRS,
                            V_ACE_MASK, cr, NULL);
                } else {
                        zl->zl_retcode = VOP_ACCESS(fvn, VREAD, 0, cr, NULL);
                }
                if (zl->zl_retcode)
                        goto zutl_done;

                vattr.va_mask = AT_ALL;
                zl->zl_retcode = VOP_GETATTR(fvn, &vattr, 0, cr, NULL);
                if (zl->zl_retcode)
                        goto zutl_done;

                zl->zl_retcode = VOP_LOOKUP(fvn, "", &xdvn, NULL,
                    flags | LOOKUP_XATTR, NULL, cr, NULL, NULL, NULL);
                if (zl->zl_retcode)
                        goto zutl_done;
                VN_RELE(fvn);
                release = xdvn;

                zl->zl_retcode = VOP_LOOKUP(xdvn, zl->zl_xfile, &xfvn,
                    NULL, flags, NULL, cr, NULL, &zl->zl_deflags, &rpn);
                if (zl->zl_retcode)
                        goto zutl_done;
                VN_RELE(xdvn);
                release = xfvn;
        }

        if (zl->zl_reqflags & ZUT_GETSTAT) {
                zl->zl_retcode = zut_stat64(release,
                    &zl->zl_statbuf, &zl->zl_xvattrs, 0, cr);
        }

zutl_done:
        (void) strlcpy(zl->zl_real, rpn.pn_path, MAXPATHLEN);

        rc = ddi_copyout(zl, (void *)arg, sizeof (zut_lookup_t), iflag);
        if (error == 0)
                error = rc;

        if (release)
                VN_RELE(release);
        if (dvn)
                VN_RELE(dvn);
        pn_free(&rpn);

zutl_bail:
        kmem_free(zl, sizeof (zut_lookup_t));
        if (rvalp)
                *rvalp = error;
        return (error);
}

/*ARGSUSED*/
static int
zut_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cr, int *rvalp)
{
        int error;

        if (getminor(dev) != 0)
                return (ENXIO);

        if (cmd <= ZUT_IOC_MIN_CMD || cmd >= ZUT_IOC_MAX_CMD)
                return (EINVAL);

        switch (cmd) {
        case ZUT_IOC_LOOKUP:
                error = zut_lookup(arg, cr, flag, rvalp);
                break;
        case ZUT_IOC_READDIR:
                error = zut_readdir(arg, cr, flag, rvalp);
        default:
                break;
        }

        return (error);
}

static int
zut_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        if (cmd != DDI_ATTACH)
                return (DDI_FAILURE);

        if (ddi_create_minor_node(dip, "zut", S_IFCHR, 0,
            DDI_PSEUDO, 0) == DDI_FAILURE)
                return (DDI_FAILURE);

        zut_dip = dip;

        ddi_report_dev(dip);

        return (DDI_SUCCESS);
}

static int
zut_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        if (cmd != DDI_DETACH)
                return (DDI_FAILURE);

        zut_dip = NULL;

        ddi_prop_remove_all(dip);
        ddi_remove_minor_node(dip, NULL);

        return (DDI_SUCCESS);
}

/*ARGSUSED*/
static int
zut_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
        switch (infocmd) {
        case DDI_INFO_DEVT2DEVINFO:
                *result = zut_dip;
                return (DDI_SUCCESS);

        case DDI_INFO_DEVT2INSTANCE:
                *result = (void *)0;
                return (DDI_SUCCESS);
        }

        return (DDI_FAILURE);
}

/*ARGSUSED*/
int
zut_open(dev_t *devp, int flag, int otyp, cred_t *cr)
{
        minor_t minor = getminor(*devp);

        if (minor == 0)                 /* This is the control device */
                return (0);

        return (ENXIO);
}

/*ARGSUSED*/
int
zut_close(dev_t dev, int flag, int otyp, cred_t *cr)
{
        minor_t minor = getminor(dev);

        if (minor == 0)         /* This is the control device */
                return (0);

        return (ENXIO);
}

/*
 * /dev/zut is the control node, i.e. minor 0.
 *
 * There are no other minor nodes, and /dev/zut basically does nothing
 * other than serve up ioctls.
 */
static struct cb_ops zut_cb_ops = {
        zut_open,       /* open */
        zut_close,      /* close */
        nodev,          /* strategy */
        nodev,          /* print */
        nodev,          /* dump */
        nodev,          /* read */
        nodev,          /* write */
        zut_ioctl,      /* ioctl */
        nodev,          /* devmap */
        nodev,          /* mmap */
        nodev,          /* segmap */
        nochpoll,       /* poll */
        ddi_prop_op,    /* prop_op */
        NULL,           /* streamtab */
        D_NEW | D_MP | D_64BIT,         /* Driver compatibility flag */
        CB_REV,         /* version */
        nodev,          /* async read */
        nodev,          /* async write */
};

static struct dev_ops zut_dev_ops = {
        DEVO_REV,       /* version */
        0,              /* refcnt */
        zut_info,       /* info */
        nulldev,        /* identify */
        nulldev,        /* probe */
        zut_attach,     /* attach */
        zut_detach,     /* detach */
        nodev,          /* reset */
        &zut_cb_ops,    /* driver operations */
        NULL            /* no bus operations */
};

static struct modldrv zut_modldrv = {
        &mod_driverops, "ZFS unit test " ZUT_VERSION_STRING,
            &zut_dev_ops
};

static struct modlinkage modlinkage = {
        MODREV_1,
        (void *)&zut_modldrv,
        NULL
};

int
_init(void)
{
        int error;

        if ((error = mod_install(&modlinkage)) != 0) {
                return (error);
        }

        error = ldi_ident_from_mod(&modlinkage, &zut_li);
        ASSERT(error == 0);

        return (0);
}

int
_fini(void)
{
        int error;

        if ((error = mod_remove(&modlinkage)) != 0)
                return (error);

        ldi_ident_release(zut_li);
        zut_li = NULL;

        return (error);
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&modlinkage, modinfop));
}