/*
 * 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 2022 RackTop Systems, Inc.
 * Copyright 2011-2021 Tintri by DDN, Inc. All rights reserved.
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/time.h>
#include <sys/varargs.h>
#include <sys/modctl.h>
#include <sys/pathname.h>
#include <sys/vnode.h>
#include <sys/socket.h>
#include <sys/ksocket.h>
#include <sys/stream.h>
#include <sys/strsubr.h>

#include <smbsrv/smb_vops.h>
#include <smbsrv/smb.h>
#include <smbsrv/smb_kproto.h>
#include <smbsrv/smb_kstat.h>

/*
 * How many iovec we'll handle as a local array (no allocation)
 * See also IOV_MAX_STACK <sys/limits.h> but we need this to
 * work also with _FAKE_KERNEL
 */
#define SMB_LOCAL_IOV_MAX       16

/*
 * SMB Network Socket API
 *
 * smb_socreate:        Creates an socket based on domain/type.
 * smb_soshutdown:      Disconnect a socket created with smb_socreate
 * smb_sodestroy:       Release resources associated with a socket
 * smb_sosend:          Send the contents of a buffer on a socket
 * smb_sorecv:          Receive data into a buffer from a socket
 * smb_iov_sosend:      Send the contents of an iovec on a socket
 * smb_iov_sorecv:      Receive data into an iovec from a socket
 */

ksocket_t
smb_socreate(int domain, int type, int protocol)
{
        ksocket_t       sock;
        int             err = 0;

        err = ksocket_socket(&sock, domain, type, protocol, KSOCKET_SLEEP,
            CRED());

        if (err != 0)
                return (NULL);
        else
                return (sock);
}

/*
 * smb_soshutdown will disconnect the socket and prevent subsequent PDU
 * reception and transmission.  The sonode still exists but its state
 * gets modified to indicate it is no longer connected.  Calls to
 * smb_sorecv/smb_iov_sorecv will return so smb_soshutdown can be used
 * regain control of a thread stuck in smb_sorecv.
 */
void
smb_soshutdown(ksocket_t so)
{
        (void) ksocket_shutdown(so, SHUT_RDWR, CRED());
}

/*
 * smb_sodestroy releases all resources associated with a socket previously
 * created with smb_socreate.  The socket must be shutdown using smb_soshutdown
 * before the socket is destroyed with smb_sodestroy, otherwise undefined
 * behavior will result.
 */
void
smb_sodestroy(ksocket_t so)
{
        (void) ksocket_close(so, CRED());
}

int
smb_sorecv(ksocket_t so, void *msg, size_t len)
{
        size_t recvd;
        int err;

        ASSERT(so != NULL);
        ASSERT(len != 0);

        if ((err = ksocket_recv(so, msg, len, MSG_WAITALL, &recvd,
            CRED())) != 0) {
                return (err);
        }

        /* Successful receive */
        return ((recvd == len) ? 0 : -1);
}

/*
 * Receive a message as an mbuf chain (returned in *mpp)
 * where the length requested is len.
 *
 * Some day hopefully this will be able to receive an actual
 * mblk chain from the network stack (without copying), and
 * either wrap those to create mbufs, or use mblks directly.
 * For now, we allocate buffers here to recv into.
 */
int
smb_net_recv_mbufs(smb_session_t *s, mbuf_t **mpp, size_t len)
{
        struct nmsghdr  msg;
        uio_t   uio;
        iovec_t iov[SMB_LOCAL_IOV_MAX];
        mbuf_t  *mhead = NULL;
        size_t  rlen;
        int     rc;

        bzero(&msg, sizeof (msg));
        bzero(&uio, sizeof (uio));
        ASSERT(len > 0);

        mhead = smb_mbuf_alloc_chain(len);

        uio.uio_resid = len;
        uio.uio_iov = iov;
        uio.uio_iovcnt = SMB_LOCAL_IOV_MAX;

        rc = smb_mbuf_mkuio(mhead, &uio);
        if (rc != 0)
                goto errout;

        msg.msg_iov = uio.uio_iov;
        msg.msg_iovlen = uio.uio_iovcnt;
        rlen = len;
        rc = ksocket_recvmsg(s->sock, &msg, MSG_WAITALL, &rlen, CRED());
        if (rc != 0)
                goto errout;
        if (rlen != len) {
                rc = SET_ERROR(EIO);
                goto errout;
        }

        *mpp = mhead;
        return (rc);

errout:
        m_freem(mhead);
        return (rc);
}

/*
 * smb_net_txl_constructor
 *
 *      Transmit list constructor
 */
void
smb_net_txl_constructor(smb_txlst_t *txl)
{
        ASSERT(txl->tl_magic != SMB_TXLST_MAGIC);

        mutex_init(&txl->tl_mutex, NULL, MUTEX_DEFAULT, NULL);
        cv_init(&txl->tl_wait_cv, NULL, CV_DEFAULT, NULL);
        txl->tl_active = B_FALSE;
        txl->tl_magic = SMB_TXLST_MAGIC;
}

/*
 * smb_net_txl_destructor
 *
 *      Transmit list destructor
 */
void
smb_net_txl_destructor(smb_txlst_t *txl)
{
        ASSERT(txl->tl_magic == SMB_TXLST_MAGIC);

        txl->tl_magic = 0;
        cv_destroy(&txl->tl_wait_cv);
        mutex_destroy(&txl->tl_mutex);
}

static void
smb_net_send_free(void *arg)
{
        mbuf_t *m = arg;
        (void) m_free(m);
}

/*
 * Create an mblk that wraps the passed mbuf
 *
 * Note we need a place to store a frtn_t for each mbuf.
 * For M_EXT packets (most are) we have lots of unused space
 * after the headers: M_dat.MH.MH_dat.MH_ext (a.k.a. m_ext)
 * If not M_EXT but there's enough trailing space, just use
 * the trailing space, otherwise convert to external type
 * (which means copying the data, so do only if necessary).
 *
 * To simplify the code, the frtn_t is always located at the
 * end of the mbuf (in space we make sure is unused).
 */
static mblk_t *
smb_net_wrap_mbuf(mbuf_t *mbuf)
{
        frtn_t          *frtn;
        mblk_t          *mblk;

        if ((mbuf->m_flags & M_EXT) == 0 &&
            M_TRAILINGSPACE(mbuf) < sizeof (*frtn)) {
                /*
                 * Convert to M_EXT type, like MCLGET(),
                 * but copy before updating mbuf->m_ext,
                 * which would otherwise overwrite data.
                 */
                caddr_t buf = smb_mbufcl_alloc();
                ASSERT(mbuf->m_len <= MLEN);
                bcopy(mbuf->m_data, buf, mbuf->m_len);
                mbuf->m_ext.ext_buf = buf;
                mbuf->m_data = buf;
                mbuf->m_flags |= M_EXT;
                mbuf->m_ext.ext_size = MCLBYTES;
                mbuf->m_ext.ext_free = smb_mbufcl_free;
        }

        /*
         * Store frtn_t at the end of the mbuf data area.
         * Note: This is the _internal_ data area (unused)
         * not the external data pointed to by m_data.
         */
        frtn = (void *) &mbuf->m_dat[MLEN - sizeof (*frtn)];

        frtn->free_func = smb_net_send_free;
        frtn->free_arg = (caddr_t)mbuf;

        mblk = esballoca_wait((void *)mbuf->m_data, mbuf->m_len,
            BPRI_MED, frtn);
        if (mblk != NULL) {
                mblk->b_wptr += mbuf->m_len;
                mblk->b_datap->db_type = M_DATA;
        }

        return (mblk);
}

/*
 * This routine sends an mbuf chain by encapsulating each segment
 * with an mblk_t setup with external storage (zero-copy).
 *
 * Note: the mbufs passed in are free'd via smb_net_send_free.
 */
static int
smb_net_send_mblks(smb_session_t *s, mbuf_t *mbuf_head)
{
        struct nmsghdr  msg;
        mblk_t  *mblk_head;
        mblk_t  *mblk_prev;
        mblk_t  *mblk;
        mbuf_t  *mbuf_prev;
        mbuf_t  *mbuf;
        smb_txlst_t *txl;
        int     rc = 0;

        bzero(&msg, sizeof (msg));

        mblk_prev = NULL;
        mblk_head = NULL;
        mbuf_prev = NULL;
        mbuf = mbuf_head;
        while (mbuf != NULL) {
                mblk = smb_net_wrap_mbuf(mbuf);
                if (mblk == NULL) {
                        rc = ENOSR;
                        break;
                }
                if (mblk_head == NULL)
                        mblk_head = mblk;
                if (mblk_prev != NULL)
                        mblk_prev->b_cont = mblk;

                mblk_prev = mblk;
                mbuf_prev = mbuf;
                mbuf = mbuf->m_next;
        }
        if (rc != 0) {
                /* Bailed with ENOSR. Cleanup */
                if (mbuf != NULL) {
                        if (mbuf_prev != NULL)
                                mbuf_prev->m_next = NULL;
                        m_freem(mbuf);
                }
                if (mblk_head != NULL)
                        freemsg(mblk_head);
                return (rc);
        }

        /*
         * Wait for our turn to send.
         */
        DTRACE_PROBE1(send__wait__start, struct smb_session_t *, s);
        txl = &s->s_txlst;
        mutex_enter(&txl->tl_mutex);
        while (txl->tl_active)
                cv_wait(&txl->tl_wait_cv, &txl->tl_mutex);
        txl->tl_active = B_TRUE;
        mutex_exit(&txl->tl_mutex);
        DTRACE_PROBE1(send__wait__done, struct smb_session_t *, s);

        /*
         * OK, send it.
         */
        rc = ksocket_sendmblk(s->sock, &msg, 0, &mblk_head, CRED());
        if (rc != 0) {
                if (mblk_head != NULL) {
                        freemsg(mblk_head);
                        mblk_head = NULL;
                }
        }

        mutex_enter(&txl->tl_mutex);
        txl->tl_active = B_FALSE;
        cv_signal(&txl->tl_wait_cv);
        mutex_exit(&txl->tl_mutex);

        return (rc);
}

/*
 * This routine sends an mbuf chain by copying its segments
 * (scatter/gather) via UIO.
 *
 * The mbuf chain is always free'd (error or not)
 */
static int
smb_net_send_uio(smb_session_t *s, mbuf_t *mbuf_head)
{
        struct nmsghdr  msg;
        uio_t   uio;
        iovec_t iov_local[SMB_LOCAL_IOV_MAX];
        mbuf_t  *mbuf;
        smb_txlst_t *txl;
        smb_vdb_t *vdb = NULL;
        size_t sent;
        int     len, nseg, rc;

        bzero(&msg, sizeof (msg));
        bzero(&uio, sizeof (uio));

        len = nseg = 0;
        for (mbuf = mbuf_head;
             mbuf != NULL;
             mbuf = mbuf->m_next) {
                nseg++;
                len += mbuf->m_len;
        }

        if (nseg <= SMB_LOCAL_IOV_MAX) {
                uio.uio_iov = iov_local;
                uio.uio_iovcnt = SMB_LOCAL_IOV_MAX;
        } else {
                vdb = kmem_alloc(sizeof (*vdb), KM_SLEEP);
                uio.uio_iov = &vdb->vdb_iovec[0];
                uio.uio_iovcnt = MAX_IOVEC;
        }
        uio.uio_resid = len;

        rc = smb_mbuf_mkuio(mbuf_head, &uio);
        if (rc != 0)
                goto out;

        DTRACE_PROBE1(send__wait__start, struct smb_session_t *, s);

        /*
         * Wait for our turn to send.
         */
        txl = &s->s_txlst;
        mutex_enter(&txl->tl_mutex);
        while (txl->tl_active)
                cv_wait(&txl->tl_wait_cv, &txl->tl_mutex);
        txl->tl_active = B_TRUE;
        mutex_exit(&txl->tl_mutex);

        DTRACE_PROBE1(send__wait__done, struct smb_session_t *, s);

        /*
         * OK, try to send.
         *
         * This should block until we've sent it all,
         * or given up due to errors (socket closed).
         */
        msg.msg_iov = uio.uio_iov;
        msg.msg_iovlen = uio.uio_iovcnt;
        while (uio.uio_resid > 0) {
                rc = ksocket_sendmsg(s->sock, &msg, 0, &sent, CRED());
                if (rc != 0)
                        break;
                uio.uio_resid -= sent;
        }

        mutex_enter(&txl->tl_mutex);
        txl->tl_active = B_FALSE;
        cv_signal(&txl->tl_wait_cv);
        mutex_exit(&txl->tl_mutex);

out:
        if (vdb != NULL)
                kmem_free(vdb, sizeof (*vdb));
        m_freem(mbuf_head);
        return (rc);
}

/*
 * This has an optional code path calling ksocket_sendmblk,
 * which is faster than ksocket_sendmsg (UIO copying) in some
 * configurations, but needs work before it's uniformly faster.
 * In particular, the ksocket_sendmblk code path probably needs
 * to do more like socopyinuio etc, checking the send socket
 * SO_SND_BUFINFO, SO_SND_COPYAVOID, etc. to find out what is
 * the preferred MSS, header space, copying preference, etc.
 *
 * As it is, this works well with some NIC drivers, particularly
 * with MTU=9000 as is typical in high performance setups, so
 * this remains available via this tunable for now.
 */
int smb_send_mblks = 0;

/*
 * smb_net_send_mbufs
 *
 * Send the buf chain using either mblk encapsulation (zero-copy)
 * or via scatter/gather UIO vector, based on the setting.
 */
int
smb_net_send_mbufs(smb_session_t *s, mbuf_t *mbuf_head)
{
        int rc;

        if (smb_send_mblks != 0) {
                rc = smb_net_send_mblks(s, mbuf_head);
        } else {
                rc = smb_net_send_uio(s, mbuf_head);
        }
        return (rc);
}