/*
 * 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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright 2018 Nexenta Systems, Inc.
 */

#include <fs/fs_subr.h>

#include <sys/errno.h>
#include <sys/file.h>
#include <sys/kmem.h>
#include <sys/kobj.h>
#include <sys/cmn_err.h>
#include <sys/stat.h>
#include <sys/systm.h>
#include <sys/sysmacros.h>
#include <sys/atomic.h>
#include <sys/vfs.h>
#include <sys/vfs_opreg.h>

#include <sharefs/sharefs.h>

/*
 * sharefs_snap_create: create a large character buffer with
 * the shares enumerated.
 */
static int
sharefs_snap_create(sharetab_globals_t *sg, shnode_t *sft)
{
        sharetab_t              *sht;
        share_t                 *sh;
        size_t                  sWritten = 0;
        int                     iCount = 0;
        char                    *buf;

        rw_enter(&sg->sharefs_lock, RW_WRITER);
        rw_enter(&sg->sharetab_lock, RW_READER);

        if (sft->sharefs_snap) {
                /*
                 * Nothing has changed, so no need to grab a new copy!
                 */
                if (sft->sharefs_generation == sg->sharetab_generation) {
                        rw_exit(&sg->sharetab_lock);
                        rw_exit(&sg->sharefs_lock);
                        return (0);
                }

                ASSERT(sft->sharefs_size != 0);
                kmem_free(sft->sharefs_snap, sft->sharefs_size + 1);
                sft->sharefs_snap = NULL;
        }

        sft->sharefs_size = sg->sharetab_size;
        sft->sharefs_count = sg->sharetab_count;

        if (sft->sharefs_size == 0) {
                rw_exit(&sg->sharetab_lock);
                rw_exit(&sg->sharefs_lock);
                return (0);
        }

        sft->sharefs_snap = kmem_zalloc(sft->sharefs_size + 1, KM_SLEEP);

        buf = sft->sharefs_snap;

        /*
         * Walk the Sharetab, dumping each entry.
         */
        for (sht = sg->sharefs_sharetab; sht != NULL; sht = sht->s_next) {
                int     i;

                for (i = 0; i < SHARETAB_HASHES; i++) {
                        for (sh = sht->s_buckets[i].ssh_sh;
                            sh != NULL;
                            sh = sh->sh_next) {
                                int     n;

                                if ((sWritten + sh->sh_size) >
                                    sft->sharefs_size) {
                                        goto error_fault;
                                }

                                /*
                                 * Note that sh->sh_size accounts
                                 * for the field seperators.
                                 * We need to add one for the EOL
                                 * marker. And we should note that
                                 * the space is accounted for in
                                 * each share by the EOS marker.
                                 */
                                n = snprintf(&buf[sWritten],
                                    sh->sh_size + 1,
                                    "%s\t%s\t%s\t%s\t%s\n",
                                    sh->sh_path,
                                    sh->sh_res,
                                    sh->sh_fstype,
                                    sh->sh_opts,
                                    sh->sh_descr);

                                if (n != sh->sh_size) {
                                        goto error_fault;
                                }

                                sWritten += n;
                                iCount++;
                        }
                }
        }

        /*
         * We want to record the generation number and
         * mtime inside this snapshot.
         */
        gethrestime(&sg->sharetab_snap_time);
        sft->sharefs_snap_time = sg->sharetab_snap_time;
        sft->sharefs_generation = sg->sharetab_generation;

        ASSERT(iCount == sft->sharefs_count);

        rw_exit(&sg->sharetab_lock);
        rw_exit(&sg->sharefs_lock);
        return (0);

error_fault:

        kmem_free(sft->sharefs_snap, sft->sharefs_size + 1);
        sft->sharefs_size = 0;
        sft->sharefs_count = 0;
        sft->sharefs_snap = NULL;
        rw_exit(&sg->sharetab_lock);
        rw_exit(&sg->sharefs_lock);

        return (EFAULT);
}

/* ARGSUSED */
static int
sharefs_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
    caller_context_t *ct)
{
        timestruc_t     now;
        shnode_t        *sft = VTOSH(vp);
        sharetab_globals_t *sg = sharetab_get_globals(vp->v_vfsp->vfs_zone);

        vap->va_type = VREG;
        vap->va_mode = S_IRUSR | S_IRGRP | S_IROTH;
        vap->va_nodeid = SHAREFS_INO_FILE;
        vap->va_nlink = 1;

        rw_enter(&sg->sharefs_lock, RW_READER);

        /*
         * If we get asked about a snapped vnode, then
         * we must report the data in that vnode.
         *
         * Else we report what is currently in the
         * sharetab.
         */
        if (sft->sharefs_real_vp) {
                rw_enter(&sg->sharetab_lock, RW_READER);
                vap->va_size = sg->sharetab_size;
                vap->va_mtime = sg->sharetab_mtime;
                rw_exit(&sg->sharetab_lock);
        } else {
                vap->va_size = sft->sharefs_size;
                vap->va_mtime = sft->sharefs_snap_time;
        }
        rw_exit(&sg->sharefs_lock);

        gethrestime(&now);
        vap->va_atime = vap->va_ctime = now;

        vap->va_uid = 0;
        vap->va_gid = 0;
        vap->va_rdev = 0;
        vap->va_blksize = DEV_BSIZE;
        vap->va_nblocks = howmany(vap->va_size, vap->va_blksize);
        vap->va_seq = 0;
        vap->va_fsid = vp->v_vfsp->vfs_dev;

        return (0);
}

/* ARGSUSED */
static int
sharefs_access(vnode_t *vp, int mode, int flags, cred_t *cr,
    caller_context_t *ct)
{
        if (mode & (VWRITE|VEXEC))
                return (EROFS);

        return (0);
}

/* ARGSUSED */
int
sharefs_open(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct)
{
        vnode_t         *vp;
        vnode_t         *ovp = *vpp;
        shnode_t        *sft;
        int             error = 0;

        if (flag & FWRITE)
                return (EINVAL);

        /*
         * Create a new sharefs vnode for each operation. In order to
         * avoid locks, we create a snapshot which can not change during
         * reads.
         */
        vp = gfs_file_create(sizeof (shnode_t), NULL, sharefs_ops_data);

        ((gfs_file_t *)vp->v_data)->gfs_ino = SHAREFS_INO_FILE;

        /*
         * Hold the parent!
         */
        VFS_HOLD(ovp->v_vfsp);

        VN_SET_VFS_TYPE_DEV(vp, ovp->v_vfsp, VREG, 0);

        vp->v_flag |= VROOT | VNOCACHE | VNOMAP | VNOSWAP | VNOMOUNT;

        *vpp = vp;
        VN_RELE(ovp);

        sft = VTOSH(vp);

        /*
         * No need for the lock, no other thread can be accessing
         * this data structure.
         */
        atomic_inc_32(&sft->sharefs_refs);
        sft->sharefs_real_vp = 0;

        /*
         * Since the sharetab could easily change on us whilst we
         * are dumping an extremely huge sharetab, we make a copy
         * of it here and use it to dump instead.
         */
        error = sharefs_snap_create(sharetab_get_globals(vp->v_vfsp->vfs_zone),
            sft);

        return (error);
}

/* ARGSUSED */
int
sharefs_close(vnode_t *vp, int flag, int count,
    offset_t off, cred_t *cr, caller_context_t *ct)
{
        shnode_t        *sft = VTOSH(vp);
        sharetab_globals_t *sg = sharetab_get_globals(vp->v_vfsp->vfs_zone);

        if (count > 1)
                return (0);

        rw_enter(&sg->sharefs_lock, RW_WRITER);
        if (vp->v_count == 1) {
                if (sft->sharefs_snap != NULL) {
                        kmem_free(sft->sharefs_snap, sft->sharefs_size + 1);
                        sft->sharefs_size = 0;
                        sft->sharefs_snap = NULL;
                        sft->sharefs_generation = 0;
                }
        }
        atomic_dec_32(&sft->sharefs_refs);
        rw_exit(&sg->sharefs_lock);

        return (0);
}

/* ARGSUSED */
static int
sharefs_read(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cr,
    caller_context_t *ct)
{
        shnode_t        *sft = VTOSH(vp);
        off_t           off = uio->uio_offset;
        size_t          len = uio->uio_resid;
        int             error = 0;
        sharetab_globals_t *sg = sharetab_get_globals(vp->v_vfsp->vfs_zone);

        rw_enter(&sg->sharefs_lock, RW_READER);

        /*
         * First check to see if we need to grab a new snapshot.
         */
        if (off == (off_t)0) {
                rw_exit(&sg->sharefs_lock);
                error = sharefs_snap_create(sg, sft);
                if (error) {
                        return (EFAULT);
                }
                rw_enter(&sg->sharefs_lock, RW_READER);
        }

        /* LINTED */
        if (len <= 0 || off >= sft->sharefs_size) {
                rw_exit(&sg->sharefs_lock);
                return (error);
        }

        if ((size_t)(off + len) > sft->sharefs_size)
                len = sft->sharefs_size - off;

        if (off < 0 || len > sft->sharefs_size) {
                rw_exit(&sg->sharefs_lock);
                return (EFAULT);
        }

        if (len != 0) {
                error = uiomove(sft->sharefs_snap + off,
                    len, UIO_READ, uio);
        }

        rw_exit(&sg->sharefs_lock);
        return (error);
}

/* ARGSUSED */
static void
sharefs_inactive(vnode_t *vp, cred_t *cr, caller_context_t *tx)
{
        gfs_file_t      *fp = vp->v_data;
        shnode_t        *sft;
        sharetab_globals_t *sg = sharetab_get_globals(vp->v_vfsp->vfs_zone);

        sft = (shnode_t *)gfs_file_inactive(vp);
        if (sft) {
                rw_enter(&sg->sharefs_lock, RW_WRITER);
                if (sft->sharefs_snap != NULL) {
                        kmem_free(sft->sharefs_snap, sft->sharefs_size + 1);
                }

                kmem_free(sft, fp->gfs_size);
                rw_exit(&sg->sharefs_lock);
        }
}

vnode_t *
sharefs_create_root_file(vfs_t *vfsp)
{
        vnode_t         *vp;
        shnode_t        *sft;

        vp = gfs_root_create_file(sizeof (shnode_t),
            vfsp, sharefs_ops_data, SHAREFS_INO_FILE);

        sft = VTOSH(vp);

        sft->sharefs_real_vp = 1;

        return (vp);
}

const fs_operation_def_t sharefs_tops_data[] = {
        { VOPNAME_OPEN,         { .vop_open = sharefs_open } },
        { VOPNAME_CLOSE,        { .vop_close = sharefs_close } },
        { VOPNAME_IOCTL,        { .error = fs_inval } },
        { VOPNAME_GETATTR,      { .vop_getattr = sharefs_getattr } },
        { VOPNAME_ACCESS,       { .vop_access = sharefs_access } },
        { VOPNAME_INACTIVE,     { .vop_inactive = sharefs_inactive } },
        { VOPNAME_READ,         { .vop_read = sharefs_read } },
        { VOPNAME_SEEK,         { .vop_seek = fs_seek } },
        { NULL }
};