/*

 * 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

 */

/*

 * Use is subject to license terms.

 */

/*

 * OPL IPSec Key Management Driver.

 *

 * This driver runs on a OPL Domain. It processes requests received

 * from the OPL Service Processor (SP) via mailbox message. It passes

 * these requests to the sckmd daemon by means of an /ioctl interface.

 *

 * Requests received from the SP consist of IPsec security associations

 * (SAs) needed to secure the communication between SC and Domain daemons

 * communicating using DSCP.

 */

#include <sys/types.h>

#include <sys/cmn_err.h>

#include <sys/kmem.h>

#include <sys/errno.h>

#include <sys/file.h>

#include <sys/open.h>

#include <sys/stat.h>

#include <sys/conf.h>

#include <sys/ddi.h>

#include <sys/cmn_err.h>

#include <sys/sunddi.h>

#include <sys/sunndi.h>

#include <sys/ddi_impldefs.h>

#include <sys/ndi_impldefs.h>

#include <sys/modctl.h>

#include <sys/disp.h>

#include <sys/note.h>

#include <sys/byteorder.h>

#include <sys/sdt.h>

#include <sys/scfd/scfdscpif.h>

#include <sys/oplkm_msg.h>

#include <sys/sckm_io.h>

#include <sys/oplkm.h>

#define	OKM_NODENAME	"oplkmdrv"		/* Node name */

#define	OKM_TARGET_ID	0			/* Target ID */

#define	OKM_SM_TOUT	5000			/* small timeout (5msec) */

#define	OKM_LG_TOUT	50000			/* large timeout (50msec) */

#define	OKM_MB_TOUT	10000000		/* Mailbox timeout (10sec) */

okms_t okms_global;				/* Global instance structure */

#ifdef DEBUG

uint32_t okm_debug = DBG_WARN;

#endif

/*

 * Prototypes for the module related functions.

 */

int okm_attach(dev_info_t *devi, ddi_attach_cmd_t cmd);

int okm_detach(dev_info_t *devi, ddi_detach_cmd_t cmd);

int okm_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result);

int okm_open(dev_t *devp, int flag, int otyp, struct cred *cred);

int okm_close(dev_t dev, int flag, int otyp, struct cred *cred);

int okm_ioctl(dev_t dev, int cmd, intptr_t data, int flag,

		cred_t *cred, int *rvalp);

/*

 * Prototypes for the internal functions.

 */

int okm_get_req(okms_t *okmsp, sckm_ioctl_getreq_t *ireqp,

    intptr_t data, int flag);

int okm_process_req(okms_t *okmsp, okm_req_hdr_t *reqp, uint32_t len,

    sckm_ioctl_getreq_t *ireqp, intptr_t data, int flag);

int okm_process_status(okms_t *okmsp, sckm_ioctl_status_t *ireply);

void okm_event_handler(scf_event_t event, void *arg);

int okm_send_reply(okms_t *okmsp, uint32_t transid, uint32_t status,

    uint32_t sadb_err, uint32_t sadb_ver);

int block_until_ready(okms_t *okmsp);

static int okm_copyin_ioctl_getreq(intptr_t userarg,

    sckm_ioctl_getreq_t *driverarg, int flag);

static int okm_copyout_ioctl_getreq(sckm_ioctl_getreq_t *driverarg,

    intptr_t userarg, int flag);

static void okm_cleanup(okms_t *okmsp);

static int okm_mbox_init(okms_t *okmsp);

static void okm_mbox_fini(okms_t *okmsp);

static clock_t okm_timeout_val(int error);

struct cb_ops okm_cb_ops = {

	okm_open,		/* open */

	okm_close,		/* close */

	nodev,			/* strategy */

	nodev,			/* print */

	nodev,			/* dump */

	nodev,			/* read */

	nodev,			/* write */

	okm_ioctl,		/* ioctl */

	nodev,			/* devmap */

	nodev,			/* mmap */

	nodev,			/* segmap */

	nochpoll,		/* poll */

	ddi_prop_op,		/* prop_op */

	0,			/* streamtab  */

	D_NEW | D_MP		/* Driver compatibility flag */

};

struct dev_ops okm_ops = {

	DEVO_REV,		/* devo_rev, */

	0,			/* refcnt  */

	okm_info,		/* get_dev_info */

	nulldev,		/* identify */

	nulldev,		/* probe */

	okm_attach,		/* attach */

	okm_detach,		/* detach */

	nodev,			/* reset */

	&okm_cb_ops,		/* driver operations */

	(struct bus_ops *)0,	/* no bus operations */

	NULL,			/* power */

	ddi_quiesce_not_needed,		/* quiesce */

};

struct modldrv modldrv = {

	&mod_driverops,

	"OPL Key Management Driver",

	&okm_ops,

};

struct modlinkage modlinkage = {

	MODREV_1,

	&modldrv,

	NULL

};

/*

 * _init - Module's init routine.

 */

int

_init(void)

{

	int ret;

	if ((ret = mod_install(&modlinkage)) != 0) {

		cmn_err(CE_WARN, "mod_install failed, error = %d", ret);

	}

	return (ret);

}

/*

 * _fini - Module's fini routine.

 */

int

_fini(void)

{

	int ret;

	if ((ret = mod_remove(&modlinkage)) != 0) {

		return (ret);

	}

	return (ret);

}

/*

 * _info - Module's info routine.

 */

int

_info(struct modinfo *modinfop)

{

	return (mod_info(&modlinkage, modinfop));

}

/*

 * okm_attach - Module's attach routine.

 *

 * Description:	Initializes the modules state structure and create

 *		the minor device node.

 */

int

okm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)

{

	int instance;

	okms_t *okmsp = &okms_global;

	instance = ddi_get_instance(dip);

	/* Only one instance is supported.  */

	if (instance != 0) {

		return (DDI_FAILURE);

	}

	if (cmd != DDI_ATTACH) {

		return (DDI_FAILURE);

	}

	okmsp->km_dip = dip;

	okmsp->km_major = ddi_driver_major(dip);

	okmsp->km_inst = instance;

	/*

	 * Get an interrupt block cookie corresponding to the

	 * interrupt priority of the event handler.

	 * Assert that the event priority is not redefined to

	 * some other priority.

	 */

	/* LINTED */

	ASSERT(SCF_EVENT_PRI == DDI_SOFTINT_LOW);

	if (ddi_get_soft_iblock_cookie(dip, SCF_EVENT_PRI,

	    &okmsp->km_ibcookie) != DDI_SUCCESS) {

		cmn_err(CE_WARN, "ddi_get_soft_iblock_cookie failed.");

		return (DDI_FAILURE);

	}

	mutex_init(&okmsp->km_lock, NULL, MUTEX_DRIVER,

	    (void *)okmsp->km_ibcookie);

	okmsp->km_clean |= OKM_CLEAN_LOCK;

	cv_init(&okmsp->km_wait, NULL, CV_DRIVER, NULL);

	okmsp->km_clean |= OKM_CLEAN_CV;

	/*

	 * set clean_node ahead as remove_node has to be called even

	 * if create node fails.

	 */

	okmsp->km_clean |= OKM_CLEAN_NODE;

	if (ddi_create_minor_node(dip, OKM_NODENAME, S_IFCHR,

	    instance, NULL, NULL) == DDI_FAILURE) {

		cmn_err(CE_WARN, "Device node creation failed");

		okm_cleanup(okmsp);

		return (DDI_FAILURE);

	}

	ddi_set_driver_private(dip, (caddr_t)okmsp);

	ddi_report_dev(dip);

	return (DDI_SUCCESS);

}

/*

 * okm_detach - Module's detach routine.

 *

 * Description:	Cleans up the module's state structures and any other

 *		relevant data.

 */

int

okm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)

{

	okms_t *okmsp;

	if (cmd != DDI_DETACH) {

		return (DDI_FAILURE);

	}

	if ((okmsp = ddi_get_driver_private(dip)) == NULL) {

		return (DDI_FAILURE);

	}

	mutex_enter(&okmsp->km_lock);

	/*

	 * Check if the mailbox is still in use.

	 */

	if (okmsp->km_state & OKM_MB_INITED) {

		mutex_exit(&okmsp->km_lock);

		cmn_err(CE_WARN, "Detach failure: Mailbox in use");

		return (DDI_FAILURE);

	}

	mutex_exit(&okmsp->km_lock);

	okm_cleanup(okmsp);

	ddi_set_driver_private(dip, NULL);

	return (DDI_SUCCESS);

}

/*

 * okm_info - Module's info routine.

 */

/* ARGSUSED */

int

okm_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)

{

	minor_t	minor;

	int	ret = DDI_FAILURE;

	switch (infocmd) {

	case DDI_INFO_DEVT2DEVINFO:

		minor = getminor((dev_t)arg);

			*result = NULL;

		} else {

			*result = okmsp->km_dip;

			ret = DDI_SUCCESS;

		}

		break;

	case DDI_INFO_DEVT2INSTANCE:

		minor = getminor((dev_t)arg);

		*result = (void *)(uintptr_t)minor;

		ret = DDI_SUCCESS;

	default:

		break;

	}

	return (ret);

}

/*

 * okm_open - Device open routine.

 *

 * Description:	Initializes the mailbox and waits until the mailbox

 *		gets connected. Only one open at a time is supported.

 */

/*ARGSUSED*/

int

okm_open(dev_t *devp, int flag, int otyp, struct cred *cred)

{

	okms_t *okmsp = &okms_global;

	int ret = 0;

	DPRINTF(DBG_DRV, ("okm_open: called\n"));

	mutex_enter(&okmsp->km_lock);

	if (okmsp->km_state & OKM_OPENED) {

		/* Only one open supported */

		mutex_exit(&okmsp->km_lock);

		DPRINTF(DBG_WARN, ("okm_open: already opened\n"));

		return (EBUSY);

	}

	okmsp->km_state |= OKM_OPENED;

	ret = block_until_ready(okmsp);

	if (ret != 0) {

		okmsp->km_state &= ~OKM_OPENED;

	}

	mutex_exit(&okmsp->km_lock);

	DPRINTF(DBG_DRV, ("okm_open: ret=%d\n", ret));

	return (ret);

}

/*

 * block_until_ready - Function to wait until the mailbox is ready to use.

 *

 * Description:	It initializes the mailbox and waits for the mailbox

 *		state to transition to connected.

 */

int

block_until_ready(okms_t *okmsp)

{

	int ret = 0;

	DPRINTF(DBG_DRV, ("block_until_ready: called\n"));

	ASSERT(MUTEX_HELD(&okmsp->km_lock));

	if (okmsp->km_state & OKM_MB_DISC) {

		DPRINTF(DBG_DRV, ("block_until_ready: closing the mailbox\n"));

		okm_mbox_fini(okmsp);

	}

	if (okmsp->km_state & OKM_MB_CONN) {

		DPRINTF(DBG_DRV, ("block_until_ready: mailbox connected\n"));

		return (0);

	}

	/*

	 * Initialize mailbox.

	 */

	if ((ret = okm_mbox_init(okmsp)) != 0) {

		DPRINTF(DBG_MBOX,

		    ("block_until_ready: mailbox init failed ret=%d\n", ret));

		return (ret);

	}

	DPRINTF(DBG_DRV, ("block_until_ready: ret=%d", ret));

	return (ret);

}

/*

 * okm_close - Device close routine.

 *

 * Description: Closes the mailbox.

 */

/*ARGSUSED*/

int

okm_close(dev_t dev, int flag, int otyp, struct cred *cred)

{

	okms_t *okmsp = &okms_global;

	DPRINTF(DBG_DRV, ("okm_close: called\n"));

	/* Close the lower layer first */

	mutex_enter(&okmsp->km_lock);

	okm_mbox_fini(okmsp);

	okmsp->km_state = 0;

	mutex_exit(&okmsp->km_lock);

	return (0);

}

/*

 * okm_ioctl - Device ioctl routine.

 *

 * Description:	Processes ioctls from the daemon.

 */

/*ARGSUSED*/

int

okm_ioctl(dev_t dev, int cmd, intptr_t data, int flag, cred_t *cred, int *rvalp)

{

	okms_t *okmsp = &okms_global;

	sckm_ioctl_getreq_t ireq;

	sckm_ioctl_status_t istatus;

	int ret = 0;

	switch (cmd) {

	case SCKM_IOCTL_GETREQ:

		DPRINTF(DBG_DRV, ("okm_ioctl: GETREQ\n"));

		if (okm_copyin_ioctl_getreq(data, &ireq, flag)) {

			return (EFAULT);

		}

		ret = okm_get_req(okmsp, &ireq, data, flag);

		DPRINTF(DBG_DRV, ("okm_ioctl: GETREQ ret=%d\n", ret));

		break;

	case SCKM_IOCTL_STATUS:

		DPRINTF(DBG_DRV, ("okm_ioctl: STATUS\n"));

		if (ddi_copyin((caddr_t)data, &istatus,

		    sizeof (sckm_ioctl_status_t), flag)) {

			return (EFAULT);

		}

		ret = okm_process_status(okmsp, &istatus);

		DPRINTF(DBG_DRV, ("okm_ioctl: STATUS ret=%d\n", ret));

		break;

	default:

		DPRINTF(DBG_DRV, ("okm_ioctl: UNKNOWN ioctl\n"));

		ret = EINVAL;

	}

	return (ret);

}

/*

 * okm_get_req - Get a request from the mailbox.

 *

 * Description:	It blocks until a message is received, then processes

 *		the message and returns it to the requestor.

 */

int

okm_get_req(okms_t *okmsp, sckm_ioctl_getreq_t *ireqp, intptr_t data, int flag)

{

	okm_req_hdr_t *reqp;

	caddr_t msgbuf;

	uint32_t len;

	int ret;

	DPRINTF(DBG_DRV, ("okm_getreq: called\n"));

	mutex_enter(&okmsp->km_lock);

	if ((ret = block_until_ready(okmsp)) != 0) {

		mutex_exit(&okmsp->km_lock);

		DPRINTF(DBG_WARN, ("okm_getreq: failed ret=%d\n", ret));

		return (ret);

	}

	if (okmsp->km_reqp != NULL) {

		DPRINTF(DBG_DRV, ("okm_getreq: req cached\n"));

		reqp = okmsp->km_reqp;

		len = okmsp->km_reqlen;

		okmsp->km_reqp = NULL;

		okmsp->km_reqlen = 0;

	} else {

retry:

		while (OKM_MBOX_READY(okmsp) &&

		    ((ret = scf_mb_canget(okmsp->km_target,

		    okmsp->km_key, &len)) != 0)) {

			if (ret != ENOMSG) {

				DPRINTF(DBG_WARN, ("okm_getreq: Unknown "

				    "mbox failure=%d\n", ret));

				mutex_exit(&okmsp->km_lock);

				return (EIO);

			}

			DPRINTF(DBG_MBOX, ("okm_getreq: waiting for mesg\n"));

			if (cv_wait_sig(&okmsp->km_wait,

			    &okmsp->km_lock) <= 0) {

				mutex_exit(&okmsp->km_lock);

				DPRINTF(DBG_DRV, ("okm_getreq:interrupted\n"));

				return (EINTR);

			}

		}

		if (!OKM_MBOX_READY(okmsp)) {

			mutex_exit(&okmsp->km_lock);

			DPRINTF(DBG_WARN, ("okm_getreq: mailbox not ready\n"));

			return (EIO);

		}

		ASSERT(len != 0);

		msgbuf = kmem_alloc(len, KM_SLEEP);

		okmsp->km_sg_rcv.msc_dptr = msgbuf;

		okmsp->km_sg_rcv.msc_len = len;

		DPRINTF(DBG_MBOX, ("okm_getreq: getmsg\n"));

		ret = scf_mb_getmsg(okmsp->km_target, okmsp->km_key, len, 1,

		    &okmsp->km_sg_rcv, 0);

		if (ret == ENOMSG || ret == EMSGSIZE) {

			kmem_free(msgbuf, len);

			DPRINTF(DBG_MBOX, ("okm_getreq: nomsg ret=%d\n", ret));

			goto retry;

		} else if (ret != 0) {

			kmem_free(msgbuf, len);

			mutex_exit(&okmsp->km_lock);

			DPRINTF(DBG_WARN,

			    ("okm_getreq: Unknown mbox failure=%d\n", ret));