dm2s.c revision 07d06da50d310a325b457d6330165aebab1e0064
/*
* 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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* DM2S - Domain side Mailbox to synchronous serial device driver.
*
* Description:
* -----------
* It is a streams driver which simulates a sync serial device on
* top of a mailbox type of communication. That is, it sends/receives
* frames as mailbox messages. The mailbox communication is provided
* by another driver, which exports the mailbox interfaces.
*
* Synchronization:
* ---------------
* This driver uses streams perimeters to simplify the synchronization.
* An inner perimeter D_MTPERMOD which protects the entire module,
* that is only one thread exists inside the perimeter, is used. As
* this driver supports only one instance and is not a high-performance
* driver, D_MTPERMOD is highly suitable.
*
* All transmission and reception of frames is done inside the service
* procedures so that all streams related operations are protected
* by the perimeters.
*
* The mailbox event handler is the only asynchronous callback which
* needs to be protected outside of the streams perimeters. This is
* done using the module private lock('ms_lock');
*
*/
#include <sys/types.h>
#include <sys/param.h>
#include <sys/stream.h>
#include <sys/cred.h>
#include <sys/systm.h>
#include <sys/sunddi.h>
#include <sys/ddi.h>
#include <sys/conf.h>
#include <sys/modctl.h>
#include <sys/mkdev.h>
#include <sys/errno.h>
#include <sys/debug.h>
#include <sys/kbio.h>
#include <sys/kmem.h>
#include <sys/consdev.h>
#include <sys/file.h>
#include <sys/stropts.h>
#include <sys/strsun.h>
#include <sys/dlpi.h>
#include <sys/stat.h>
#include <sys/ser_sync.h>
#include <sys/sysmacros.h>
#include <sys/note.h>
#include <sys/sdt.h>
#include <sys/scfd/scfdscpif.h>
#include <sys/dm2s.h>
#define DM2S_MODNAME "dm2s" /* Module name */
#define DM2S_TARGET_ID 0 /* Target ID of the peer */
#define DM2S_ID_NUM 0x4D53 /* 'M''S' */
#define DM2S_DEF_MTU 1504 /* Def. MTU size + PPP bytes */
#define DM2S_MAXPSZ DM2S_DEF_MTU /* Set it to the default MTU */
#define DM2S_LOWAT (4 * 1024) /* Low water mark */
#define DM2S_HIWAT (12 * 1024) /* High water mark */
#define DM2S_SM_TOUT 5000 /* Small timeout (5msec) */
#define DM2S_LG_TOUT 50000 /* Large timeout (50msec) */
#define DM2S_MB_TOUT 10000000 /* Mailbox timeout (10sec) */
/*
* Global variables
*/
void *dm2s_softstate = NULL; /* Softstate pointer */
/*
* Prototypes for the module related functions.
*/
int dm2s_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
int dm2s_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
int dm2s_info(dev_info_t *dip, ddi_info_cmd_t infocmd,
void *arg, void **result);
/*
* Prototypes for the streams related functions.
*/
int dm2s_open(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr);
int dm2s_close(queue_t *rq, int flag, cred_t *cred);
int dm2s_wput(queue_t *wq, mblk_t *mp);
int dm2s_rsrv(queue_t *rq);
int dm2s_wsrv(queue_t *wq);
/*
* Prototypes for the internal functions.
*/
void dm2s_start(queue_t *wq, dm2s_t *dm2sp);
void dm2s_event_handler(scf_event_t event, void *arg);
int dm2s_transmit(queue_t *wq, mblk_t *mp, target_id_t target, mkey_t key);
void dm2s_receive(dm2s_t *dm2sp);
void dm2s_wq_timeout(void *arg);
void dm2s_rq_timeout(void *arg);
void dm2s_bufcall_rcv(void *arg);
static clock_t dm2s_timeout_val(int error);
static void dm2s_cleanup(dm2s_t *dm2sp);
static int dm2s_mbox_init(dm2s_t *dm2sp);
static void dm2s_mbox_fini(dm2s_t *dm2sp);
static int dm2s_prep_scatgath(mblk_t *mp, uint32_t *numsg,
mscat_gath_t *sgp, int maxsg);
#ifdef DEBUG
uint32_t dm2s_debug = DBG_WARN;
#endif /* DEBUG */
/*
* Streams and module related structures.
*/
struct module_info dm2s_module_info = {
DM2S_ID_NUM, /* module ID number */
DM2S_MODNAME, /* module name. */
0, /* Minimum packet size (none) */
DM2S_MAXPSZ, /* Maximum packet size (none) */
DM2S_HIWAT, /* queue high water mark */
DM2S_LOWAT /* queue low water mark */
};
struct qinit dm2s_rinit = {
putq, /* qi_putp */
dm2s_rsrv, /* qi_srvp */
dm2s_open, /* qi_qopen */
dm2s_close, /* qi_qlcose */
NULL, /* qi_qadmin */
&dm2s_module_info, /* qi_minfo */
NULL /* qi_mstat */
};
struct qinit dm2s_winit = {
dm2s_wput, /* qi_putp */
dm2s_wsrv, /* qi_srvp */
NULL, /* qi_qopen */
NULL, /* qi_qlcose */
NULL, /* qi_qadmin */
&dm2s_module_info, /* qi_minfo */
NULL /* qi_mstat */
};
struct streamtab dm2s_streamtab = {
&dm2s_rinit,
&dm2s_winit,
NULL,
NULL
};
DDI_DEFINE_STREAM_OPS(dm2s_ops, nulldev, nulldev, dm2s_attach, \
dm2s_detach, nodev, dm2s_info, D_NEW | D_MP | D_MTPERMOD, \
&dm2s_streamtab, ddi_quiesce_not_supported);
struct modldrv modldrv = {
&mod_driverops,
"OPL Mbox to Serial Driver",
&dm2s_ops
};
struct modlinkage modlinkage = {
MODREV_1,
&modldrv,
NULL
};
/*
* _init - Module's init routine.
*/
int
_init(void)
{
int ret;
if (ddi_soft_state_init(&dm2s_softstate, sizeof (dm2s_t), 1) != 0) {
cmn_err(CE_WARN, "softstate initialization failed\n");
return (DDI_FAILURE);
}
if ((ret = mod_install(&modlinkage)) != 0) {
cmn_err(CE_WARN, "mod_install failed, error = %d", ret);
ddi_soft_state_fini(&dm2s_softstate);
}
return (ret);
}
/*
* _fini - Module's fini routine.
*/
int
_fini(void)
{
int ret;
if ((ret = mod_remove(&modlinkage)) != 0) {
return (ret);
}
ddi_soft_state_fini(&dm2s_softstate);
return (ret);
}
/*
* _info - Module's info routine.
*/
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
/*
* dm2s_attach - Module's attach routine.
*/
int
dm2s_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int instance;
dm2s_t *dm2sp;
char name[20];
instance = ddi_get_instance(dip);
/* Only one instance is supported. */
if (instance != 0) {
cmn_err(CE_WARN, "only one instance is supported");
return (DDI_FAILURE);
}
if (cmd != DDI_ATTACH) {
return (DDI_FAILURE);
}
if (ddi_soft_state_zalloc(dm2s_softstate, instance) != DDI_SUCCESS) {
cmn_err(CE_WARN, "softstate allocation failure");
return (DDI_FAILURE);
}
dm2sp = (dm2s_t *)ddi_get_soft_state(dm2s_softstate, instance);
if (dm2sp == NULL) {
ddi_soft_state_free(dm2s_softstate, instance);
cmn_err(CE_WARN, "softstate allocation failure.");
return (DDI_FAILURE);
}
dm2sp->ms_dip = dip;
dm2sp->ms_major = ddi_driver_major(dip);
dm2sp->ms_ppa = instance;
/*
* Get an interrupt block cookie corresponding to the
* interrupt priority of the event handler.
* Assert that the event priority is not re-defined to
* some higher priority.
*/
/* LINTED */
ASSERT(SCF_EVENT_PRI == DDI_SOFTINT_LOW);
if (ddi_get_soft_iblock_cookie(dip, SCF_EVENT_PRI,
&dm2sp->ms_ibcookie) != DDI_SUCCESS) {
cmn_err(CE_WARN, "ddi_get_soft_iblock_cookie failed.");
goto error;
}
mutex_init(&dm2sp->ms_lock, NULL, MUTEX_DRIVER,
(void *)dm2sp->ms_ibcookie);
dm2sp->ms_clean |= DM2S_CLEAN_LOCK;
cv_init(&dm2sp->ms_wait, NULL, CV_DRIVER, NULL);
dm2sp->ms_clean |= DM2S_CLEAN_CV;
(void) sprintf(name, "%s%d", DM2S_MODNAME, instance);
if (ddi_create_minor_node(dip, name, S_IFCHR, instance,
DDI_PSEUDO, NULL) == DDI_FAILURE) {
ddi_remove_minor_node(dip, NULL);
cmn_err(CE_WARN, "Device node creation failed.");
goto error;
}
dm2sp->ms_clean |= DM2S_CLEAN_NODE;
ddi_set_driver_private(dip, (caddr_t)dm2sp);
ddi_report_dev(dip);
return (DDI_SUCCESS);
error:
dm2s_cleanup(dm2sp);
return (DDI_FAILURE);
}
/*
* dm2s_info - Module's info routine.
*/
/*ARGSUSED*/
int
dm2s_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
dm2s_t *dm2sp;
minor_t minor;
int ret = DDI_FAILURE;
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
minor = getminor((dev_t)arg);
dm2sp = (dm2s_t *)ddi_get_soft_state(dm2s_softstate, minor);
if (dm2sp == NULL) {
*result = NULL;
} else {
*result = dm2sp->ms_dip;
ret = DDI_SUCCESS;
}
break;
case DDI_INFO_DEVT2INSTANCE:
minor = getminor((dev_t)arg);
*result = (void *)(uintptr_t)minor;
ret = DDI_SUCCESS;
break;
default:
break;
}
return (ret);
}
/*
* dm2s_detach - Module's detach routine.
*/
int
dm2s_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
int instance;
dm2s_t *dm2sp;
if (cmd != DDI_DETACH) {
return (DDI_FAILURE);
}
instance = ddi_get_instance(dip);
dm2sp = (dm2s_t *)ddi_get_soft_state(dm2s_softstate, instance);
if (dm2sp == NULL) {
return (DDI_FAILURE);
}
mutex_enter(&dm2sp->ms_lock);
/* Check if the mailbox is still in use. */
if (dm2sp->ms_state & DM2S_MB_INITED) {
mutex_exit(&dm2sp->ms_lock);
cmn_err(CE_WARN, "Mailbox in use: Detach failed");
return (DDI_FAILURE);
}
mutex_exit(&dm2sp->ms_lock);
dm2s_cleanup(dm2sp);
return (DDI_SUCCESS);
}
/*
* dm2s_open - Device open routine.
*
* Only one open supported. Clone open is not supported.
*/
/* ARGSUSED */
int
dm2s_open(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr)
{
dm2s_t *dm2sp;
int instance = getminor(*dev);
int ret = 0;
DPRINTF(DBG_DRV, ("dm2s_open: called\n"));
if (sflag == CLONEOPEN) {
/* Clone open not supported */
DPRINTF(DBG_WARN, ("dm2s_open: clone open not supported\n"));
return (ENOTSUP);
}
if (rq->q_ptr != NULL) {
DPRINTF(DBG_WARN, ("dm2s_open: already opened\n"));
return (EBUSY);
}
if ((dm2sp = ddi_get_soft_state(dm2s_softstate, instance)) == NULL) {
DPRINTF(DBG_WARN, ("dm2s_open: instance not found\n"));
return (ENODEV);
}
mutex_enter(&dm2sp->ms_lock);
if (dm2sp->ms_state & DM2S_OPENED) {
/* Only one open supported */
mutex_exit(&dm2sp->ms_lock);
DPRINTF(DBG_WARN, ("dm2s_open: already opened\n"));
return (EBUSY);
}
dm2sp->ms_state |= DM2S_OPENED;
/* Initialize the mailbox. */
if ((ret = dm2s_mbox_init(dm2sp)) != 0) {
dm2sp->ms_state = 0;
mutex_exit(&dm2sp->ms_lock);
return (ret);
}
rq->q_ptr = WR(rq)->q_ptr = (void *)dm2sp;
dm2sp->ms_rq = rq;
dm2sp->ms_wq = WR(rq);
mutex_exit(&dm2sp->ms_lock);
if (ret == 0) {
qprocson(rq); /* now schedule our queue */
}
DPRINTF(DBG_DRV, ("dm2s_open: ret=%d\n", ret));
return (ret);
}
/*
* dm2s_close - Device close routine.
*/
/* ARGSUSED */
int
dm2s_close(queue_t *rq, int flag, cred_t *cred)
{
dm2s_t *dm2sp = (dm2s_t *)rq->q_ptr;
DPRINTF(DBG_DRV, ("dm2s_close: called\n"));
if (dm2sp == NULL) {
/* Already closed once */
return (ENODEV);
}
/* Close the lower layer first */
mutex_enter(&dm2sp->ms_lock);
(void) scf_mb_flush(dm2sp->ms_target, dm2sp->ms_key, MB_FLUSH_ALL);
dm2s_mbox_fini(dm2sp);
mutex_exit(&dm2sp->ms_lock);
/*
* Now we can assume that no asynchronous callbacks exist.
* Poison the stream head so that we can't be pushed again.
*/
(void) putnextctl(rq, M_HANGUP);
qprocsoff(rq);
if (dm2sp->ms_rbufcid != 0) {
qunbufcall(rq, dm2sp->ms_rbufcid);
dm2sp->ms_rbufcid = 0;
}
if (dm2sp->ms_rq_timeoutid != 0) {
DTRACE_PROBE1(dm2s_rqtimeout__cancel, dm2s_t, dm2sp);
(void) quntimeout(dm2sp->ms_rq, dm2sp->ms_rq_timeoutid);
dm2sp->ms_rq_timeoutid = 0;
}
if (dm2sp->ms_wq_timeoutid != 0) {
DTRACE_PROBE1(dm2s_wqtimeout__cancel, dm2s_t, dm2sp);
(void) quntimeout(dm2sp->ms_wq, dm2sp->ms_wq_timeoutid);
dm2sp->ms_wq_timeoutid = 0;
}
/*
* Now we can really mark it closed.
*/
mutex_enter(&dm2sp->ms_lock);
dm2sp->ms_rq = dm2sp->ms_wq = NULL;
dm2sp->ms_state &= ~DM2S_OPENED;
mutex_exit(&dm2sp->ms_lock);
rq->q_ptr = WR(rq)->q_ptr = NULL;
(void) qassociate(rq, -1);
DPRINTF(DBG_DRV, ("dm2s_close: successfully closed\n"));
return (0);
}
/*
* dm2s_rsrv - Streams read side service procedure.
*
* All messages are received in the service procedure
* only. This is done to simplify the streams synchronization.
*/
int
dm2s_rsrv(queue_t *rq)
{
mblk_t *mp;
dm2s_t *dm2sp = (dm2s_t *)rq->q_ptr;
DPRINTF(DBG_DRV, ("dm2s_rsrv: called\n"));
ASSERT(dm2sp != NULL);
mutex_enter(&dm2sp->ms_lock);
/* Receive if there are any messages waiting in the mailbox. */
dm2s_receive(dm2sp);
mutex_exit(&dm2sp->ms_lock);
/* Send the received messages up the stream. */
while ((mp = getq(rq)) != NULL) {
if (canputnext(rq)) {
putnext(rq, mp);
} else {
(void) putbq(rq, mp);
break;
}
}
DPRINTF(DBG_DRV, ("dm2s_rsrv: return\n"));
return (0);
}
/*
* dm2s_wsrv - Streams write side service procedure.
*
* All messages are transmitted in the service procedure
* only. This is done to simplify the streams synchronization.
*/
int
dm2s_wsrv(queue_t *wq)
{
dm2s_t *dm2sp = (dm2s_t *)wq->q_ptr;
DPRINTF(DBG_DRV, ("dm2s_wsrv: called\n"));
ASSERT(dm2sp != NULL);
/* Lets cancel any timeouts waiting to be scheduled. */
if (dm2sp->ms_wq_timeoutid != 0) {
DTRACE_PROBE1(dm2s_wqtimeout__cancel, dm2s_t, dm2sp);
(void) quntimeout(dm2sp->ms_wq, dm2sp->ms_wq_timeoutid);
dm2sp->ms_wq_timeoutid = 0;
}
mutex_enter(&dm2sp->ms_lock);
dm2s_start(wq, dm2sp);
mutex_exit(&dm2sp->ms_lock);
DPRINTF(DBG_DRV, ("dm2s_wsrv: return\n"));
return (0);
}
/*
* dm2s_wput - Streams write side put routine.
*
* All M_DATA messages are queued so that they are transmitted in
* the service procedure. This is done to simplify the streams
* synchronization. Other messages are handled appropriately.
*/
int
dm2s_wput(queue_t *wq, mblk_t *mp)
{
dm2s_t *dm2sp = (dm2s_t *)wq->q_ptr;
DPRINTF(DBG_DRV, ("dm2s_wput: called\n"));
if (dm2sp == NULL) {
return (ENODEV); /* Can't happen. */
}
switch (mp->b_datap->db_type) {
case (M_DATA):
DPRINTF(DBG_DRV, ("dm2s_wput: M_DATA message\n"));
while (mp->b_wptr == mp->b_rptr) {
mblk_t *mp1;
mp1 = unlinkb(mp);
freemsg(mp);
mp = mp1;
if (mp == NULL) {
return (0);
}
}
/*
* Simply queue the message and handle it in the service
* procedure.
*/
(void) putq(wq, mp);
qenable(wq);
return (0);
case (M_PROTO):
DPRINTF(DBG_DRV, ("dm2s_wput: M_PROTO message\n"));
/* We don't expect this */
mp->b_datap->db_type = M_ERROR;
mp->b_rptr = mp->b_wptr = mp->b_datap->db_base;
*mp->b_wptr++ = EPROTO;
qreply(wq, mp);
return (EINVAL);
case (M_IOCTL):
DPRINTF(DBG_DRV, ("dm2s_wput: M_IOCTL message\n"));
if (MBLKL(mp) < sizeof (struct iocblk)) {
freemsg(mp);
return (0);
}
/*
* No ioctls required to be supported by this driver, so
* return EINVAL for all ioctls.
*/
miocnak(wq, mp, 0, EINVAL);
break;
case (M_CTL):
DPRINTF(DBG_DRV, ("dm2s_wput: M_CTL message\n"));
/*
* No M_CTL messages need to supported by this driver,
* so simply ignore them.
*/
freemsg(mp);
break;
case (M_FLUSH):
DPRINTF(DBG_DRV, (
"dm2s_wput: M_FLUSH message 0x%X\n", *mp->b_rptr));
if (*mp->b_rptr & FLUSHW) { /* Flush write-side */
(void) scf_mb_flush(dm2sp->ms_target, dm2sp->ms_key,
MB_FLUSH_SEND);
flushq(wq, FLUSHDATA);
*mp->b_rptr &= ~FLUSHW;
}
if (*mp->b_rptr & FLUSHR) {
(void) scf_mb_flush(dm2sp->ms_target, dm2sp->ms_key,
MB_FLUSH_RECEIVE);
flushq(RD(wq), FLUSHDATA);
qreply(wq, mp);
} else {
freemsg(mp);
}
break;
default:
DPRINTF(DBG_DRV, ("dm2s_wput: UNKNOWN message\n"));
freemsg(mp);
}
return (0);
}
/*
* dm2s_cleanup - Cleanup routine.
*/
static void
dm2s_cleanup(dm2s_t *dm2sp)
{
char name[20];
DPRINTF(DBG_DRV, ("dm2s_cleanup: called\n"));
ASSERT(dm2sp != NULL);
if (dm2sp->ms_clean & DM2S_CLEAN_NODE) {
(void) sprintf(name, "%s%d", DM2S_MODNAME, dm2sp->ms_ppa);
ddi_remove_minor_node(dm2sp->ms_dip, name);
}
if (dm2sp->ms_clean & DM2S_CLEAN_LOCK)
mutex_destroy(&dm2sp->ms_lock);
if (dm2sp->ms_clean & DM2S_CLEAN_CV)
cv_destroy(&dm2sp->ms_wait);
ddi_set_driver_private(dm2sp->ms_dip, NULL);
ddi_soft_state_free(dm2s_softstate, dm2sp->ms_ppa);
}
/*
* dm2s_mbox_init - Mailbox specific initialization.
*/
static int
dm2s_mbox_init(dm2s_t *dm2sp)
{
int ret;
clock_t tout = drv_usectohz(DM2S_MB_TOUT);
ASSERT(MUTEX_HELD(&dm2sp->ms_lock));
dm2sp->ms_target = DM2S_TARGET_ID;
dm2sp->ms_key = DSCP_KEY;
dm2sp->ms_state &= ~DM2S_MB_INITED;
/* Iterate until mailbox gets connected */
while (!(dm2sp->ms_state & DM2S_MB_CONN)) {
DPRINTF(DBG_MBOX, ("dm2s_mbox_init: calling mb_init\n"));
ret = scf_mb_init(dm2sp->ms_target, dm2sp->ms_key,
dm2s_event_handler, (void *)dm2sp);
DPRINTF(DBG_MBOX, ("dm2s_mbox_init: mb_init ret=%d\n", ret));
if (ret != 0) {
DPRINTF(DBG_MBOX,
("dm2s_mbox_init: failed ret =%d\n", ret));
DTRACE_PROBE1(dm2s_mbox_fail, int, ret);
} else {
dm2sp->ms_state |= DM2S_MB_INITED;
/* Block until the mailbox is ready to communicate. */
while (!(dm2sp->ms_state &
(DM2S_MB_CONN | DM2S_MB_DISC))) {
if (cv_wait_sig(&dm2sp->ms_wait,
&dm2sp->ms_lock) <= 0) {
/* interrupted */
ret = EINTR;
break;
}
}
}
if ((ret != 0) || (dm2sp->ms_state & DM2S_MB_DISC)) {
if (dm2sp->ms_state & DM2S_MB_INITED) {
(void) scf_mb_fini(dm2sp->ms_target,
dm2sp->ms_key);
}
if (dm2sp->ms_state & DM2S_MB_DISC) {
DPRINTF(DBG_WARN,
("dm2s_mbox_init: mbox DISC_ERROR\n"));
DTRACE_PROBE1(dm2s_mbox_fail,
int, DM2S_MB_DISC);
}
dm2sp->ms_state &= ~(DM2S_MB_INITED | DM2S_MB_DISC |
DM2S_MB_CONN);
if (ret == EINTR) {
return (ret);
}
/*
* If there was failure, then wait for
* DM2S_MB_TOUT secs and retry again.
*/
DPRINTF(DBG_MBOX, ("dm2s_mbox_init: waiting...\n"));
ret = cv_reltimedwait_sig(&dm2sp->ms_wait,
&dm2sp->ms_lock, tout, TR_CLOCK_TICK);
if (ret == 0) {
/* if interrupted, return immediately. */
DPRINTF(DBG_MBOX,
("dm2s_mbox_init: interrupted\n"));
return (EINTR);
}
}
}
/*
* Obtain the max size of a single message.
* NOTE: There is no mechanism to update the
* upperlayers dynamically, so we expect this
* size to be atleast the default MTU size.
*/
ret = scf_mb_ctrl(dm2sp->ms_target, dm2sp->ms_key,
SCF_MBOP_MAXMSGSIZE, &dm2sp->ms_mtu);
if ((ret == 0) && (dm2sp->ms_mtu < DM2S_DEF_MTU)) {
cmn_err(CE_WARN, "Max message size expected >= %d "
"but found %d\n", DM2S_DEF_MTU, dm2sp->ms_mtu);
ret = EIO;
}
if (ret != 0) {
dm2sp->ms_state &= ~DM2S_MB_INITED;
(void) scf_mb_fini(dm2sp->ms_target, dm2sp->ms_key);
}
DPRINTF(DBG_MBOX, ("dm2s_mbox_init: mb_init ret=%d\n", ret));
return (ret);
}
/*
* dm2s_mbox_fini - Mailbox de-initialization.
*/
static void
dm2s_mbox_fini(dm2s_t *dm2sp)
{
int ret;
ASSERT(dm2sp != NULL);
if (dm2sp->ms_state & DM2S_MB_INITED) {
DPRINTF(DBG_MBOX, ("dm2s_mbox_fini: calling mb_fini\n"));
ret = scf_mb_fini(dm2sp->ms_target, dm2sp->ms_key);
if (ret != 0) {
cmn_err(CE_WARN,
"Failed to close the Mailbox error =%d", ret);
}
DPRINTF(DBG_MBOX, ("dm2s_mbox_fini: mb_fini ret=%d\n", ret));
dm2sp->ms_state &= ~(DM2S_MB_INITED |DM2S_MB_CONN |
DM2S_MB_DISC);
}
}
/*
* dm2s_event_handler - Mailbox event handler.
*/
void
dm2s_event_handler(scf_event_t event, void *arg)
{
dm2s_t *dm2sp = (dm2s_t *)arg;
queue_t *rq;
ASSERT(dm2sp != NULL);
mutex_enter(&dm2sp->ms_lock);
if (!(dm2sp->ms_state & DM2S_MB_INITED)) {
/*
* Ignore all events if the state flag indicates that the
* mailbox not initialized, this may happen during the close.
*/
mutex_exit(&dm2sp->ms_lock);
DPRINTF(DBG_MBOX,
("Event(0x%X) received - Mailbox not inited\n", event));
return;
}
switch (event) {
case SCF_MB_CONN_OK:
/*
* Now the mailbox is ready to use, lets wake up
* any one waiting for this event.
*/
dm2sp->ms_state |= DM2S_MB_CONN;
cv_broadcast(&dm2sp->ms_wait);
DPRINTF(DBG_MBOX, ("Event received = CONN_OK\n"));
break;
case SCF_MB_MSG_DATA:
if (!DM2S_MBOX_READY(dm2sp)) {
DPRINTF(DBG_MBOX,
("Event(MSG_DATA) received - Mailbox not READY\n"));
break;
}
/*
* A message is available in the mailbox.
* Lets enable the read service procedure
* to receive this message.
*/
if (dm2sp->ms_rq != NULL) {
qenable(dm2sp->ms_rq);
}
DPRINTF(DBG_MBOX, ("Event received = MSG_DATA\n"));
break;
case SCF_MB_SPACE:
if (!DM2S_MBOX_READY(dm2sp)) {
DPRINTF(DBG_MBOX,
("Event(MB_SPACE) received - Mailbox not READY\n"));
break;
}
/*
* Now the mailbox is ready to transmit, lets
* schedule the write service procedure.
*/
if (dm2sp->ms_wq != NULL) {
qenable(dm2sp->ms_wq);
}
DPRINTF(DBG_MBOX, ("Event received = MB_SPACE\n"));
break;
case SCF_MB_DISC_ERROR:
dm2sp->ms_state |= DM2S_MB_DISC;
if (dm2sp->ms_state & DM2S_MB_CONN) {
/*
* If it was previously connected,
* then send a hangup message.
*/
rq = dm2sp->ms_rq;
if (rq != NULL) {
mutex_exit(&dm2sp->ms_lock);
/*
* Send a hangup message to indicate
* disconnect event.
*/
(void) putctl(rq, M_HANGUP);
DTRACE_PROBE1(dm2s_hangup, dm2s_t, dm2sp);
mutex_enter(&dm2sp->ms_lock);
}
} else {
/*
* Signal if the open is waiting for a
* connection.
*/
cv_broadcast(&dm2sp->ms_wait);
}
DPRINTF(DBG_MBOX, ("Event received = DISC_ERROR\n"));
break;
default:
cmn_err(CE_WARN, "Unexpected event received\n");
break;
}
mutex_exit(&dm2sp->ms_lock);
}
/*
* dm2s_start - Start transmission function.
*
* Send all queued messages. If the mailbox is busy, then
* start a timeout as a polling mechanism. The timeout is useful
* to not rely entirely on the SCF_MB_SPACE event.
*/
void
dm2s_start(queue_t *wq, dm2s_t *dm2sp)
{
mblk_t *mp;
int ret;
DPRINTF(DBG_DRV, ("dm2s_start: called\n"));
ASSERT(dm2sp != NULL);
ASSERT(MUTEX_HELD(&dm2sp->ms_lock));
while ((mp = getq(wq)) != NULL) {
switch (mp->b_datap->db_type) {
case M_DATA:
ret = dm2s_transmit(wq, mp, dm2sp->ms_target,
dm2sp->ms_key);
if (ret == EBUSY || ret == ENOSPC || ret == EAGAIN) {
DPRINTF(DBG_MBOX,
("dm2s_start: recoverable err=%d\n", ret));
/*
* Start a timeout to retry again.
*/
if (dm2sp->ms_wq_timeoutid == 0) {
DTRACE_PROBE1(dm2s_wqtimeout__start,
dm2s_t, dm2sp);
dm2sp->ms_wq_timeoutid = qtimeout(wq,
dm2s_wq_timeout, (void *)dm2sp,
dm2s_timeout_val(ret));
}
return;
} else if (ret != 0) {
mutex_exit(&dm2sp->ms_lock);
/*
* An error occurred with the transmission,
* flush pending messages and initiate a
* hangup.
*/
flushq(wq, FLUSHDATA);
(void) putnextctl(RD(wq), M_HANGUP);
DTRACE_PROBE1(dm2s_hangup, dm2s_t, dm2sp);
DPRINTF(DBG_WARN,
("dm2s_start: hangup transmit err=%d\n",
ret));
mutex_enter(&dm2sp->ms_lock);
}
break;
default:
/*
* At this point, we don't expect any other messages.
*/
freemsg(mp);
break;
}
}
}
/*
* dm2s_receive - Read all messages from the mailbox.
*
* This function is called from the read service procedure, to
* receive the messages awaiting in the mailbox.
*/
void
dm2s_receive(dm2s_t *dm2sp)
{
queue_t *rq = dm2sp->ms_rq;
mblk_t *mp;
int ret;
uint32_t len;
DPRINTF(DBG_DRV, ("dm2s_receive: called\n"));
ASSERT(dm2sp != NULL);
ASSERT(MUTEX_HELD(&dm2sp->ms_lock));
if (rq == NULL) {
return;
}
/*
* As the number of messages in the mailbox are pretty limited,
* it is safe to process all messages in one loop.
*/
while (DM2S_MBOX_READY(dm2sp) && ((ret = scf_mb_canget(dm2sp->ms_target,
dm2sp->ms_key, &len)) == 0)) {
DPRINTF(DBG_MBOX, ("dm2s_receive: mb_canget len=%d\n", len));
if (len == 0) {
break;
}
mp = allocb(len, BPRI_MED);
if (mp == NULL) {
DPRINTF(DBG_WARN, ("dm2s_receive: allocb failed\n"));
/*
* Start a bufcall so that we can retry again
* when memory becomes available.
*/
dm2sp->ms_rbufcid = qbufcall(rq, len, BPRI_MED,
dm2s_bufcall_rcv, dm2sp);
if (dm2sp->ms_rbufcid == 0) {
DPRINTF(DBG_WARN,
("dm2s_receive: qbufcall failed\n"));
/*
* if bufcall fails, start a timeout to
* initiate a re-try after some time.
*/
DTRACE_PROBE1(dm2s_rqtimeout__start,
dm2s_t, dm2sp);
dm2sp->ms_rq_timeoutid = qtimeout(rq,
dm2s_rq_timeout, (void *)dm2sp,
drv_usectohz(DM2S_SM_TOUT));
}
break;
}
/*
* Only a single scatter/gather element is enough here.
*/
dm2sp->ms_sg_rcv.msc_dptr = (caddr_t)mp->b_wptr;
dm2sp->ms_sg_rcv.msc_len = len;
DPRINTF(DBG_MBOX, ("dm2s_receive: calling getmsg\n"));
ret = scf_mb_getmsg(dm2sp->ms_target, dm2sp->ms_key, len, 1,
&dm2sp->ms_sg_rcv, 0);
DPRINTF(DBG_MBOX, ("dm2s_receive: getmsg ret=%d\n", ret));
if (ret != 0) {
freemsg(mp);
break;
}
DMPBYTES("dm2s: Getmsg: ", len, 1, &dm2sp->ms_sg_rcv);
mp->b_wptr += len;
/*
* Queue the messages in the rq, so that the service
* procedure handles sending the messages up the stream.
*/
(void) putq(rq, mp);
}
if ((!DM2S_MBOX_READY(dm2sp)) || (ret != ENOMSG && ret != EMSGSIZE)) {
/*
* Some thing went wrong, flush pending messages
* and initiate a hangup.
* Note: flushing the wq initiates a faster close.
*/
mutex_exit(&dm2sp->ms_lock);
flushq(WR(rq), FLUSHDATA);
(void) putnextctl(rq, M_HANGUP);
DTRACE_PROBE1(dm2s_hangup, dm2s_t, dm2sp);
mutex_enter(&dm2sp->ms_lock);
DPRINTF(DBG_WARN, ("dm2s_receive: encountered unknown "
"condition - hangup ret=%d\n", ret));
}
}
/*
* dm2s_transmit - Transmit a message.
*/
int
dm2s_transmit(queue_t *wq, mblk_t *mp, target_id_t target, mkey_t key)
{
dm2s_t *dm2sp = (dm2s_t *)wq->q_ptr;
int ret;
uint32_t len;
uint32_t numsg;
DPRINTF(DBG_DRV, ("dm2s_transmit: called\n"));
ASSERT(dm2sp != NULL);
ASSERT(MUTEX_HELD(&dm2sp->ms_lock));
/*
* Free the message if the mailbox is not in the connected state.
*/
if (!DM2S_MBOX_READY(dm2sp)) {
DPRINTF(DBG_MBOX, ("dm2s_transmit: mailbox not ready yet\n"));
freemsg(mp);
return (EIO);
}
len = msgdsize(mp);
if (len > dm2sp->ms_mtu) {
/*
* Size is too big to send, free the message.
*/
DPRINTF(DBG_MBOX, ("dm2s_transmit: message too large\n"));
DTRACE_PROBE2(dm2s_msg_too_big, dm2s_t, dm2sp, uint32_t, len);
freemsg(mp);
return (0);
}
if ((ret = dm2s_prep_scatgath(mp, &numsg, dm2sp->ms_sg_tx,
DM2S_MAX_SG)) != 0) {
DPRINTF(DBG_MBOX, ("dm2s_transmit: prep_scatgath failed\n"));
(void) putbq(wq, mp);
return (EAGAIN);
}
DPRINTF(DBG_MBOX, ("dm2s_transmit: calling mb_putmsg numsg=%d len=%d\n",
numsg, len));
ret = scf_mb_putmsg(target, key, len, numsg, dm2sp->ms_sg_tx, 0);
if (ret == EBUSY || ret == ENOSPC) {
DPRINTF(DBG_MBOX,
("dm2s_transmit: mailbox busy ret=%d\n", ret));
if (++dm2sp->ms_retries >= DM2S_MAX_RETRIES) {
/*
* If maximum retries are reached, then free the
* message.
*/
DPRINTF(DBG_MBOX,
("dm2s_transmit: freeing msg after max retries\n"));
DTRACE_PROBE2(dm2s_retry_fail, dm2s_t, dm2sp, int, ret);
freemsg(mp);
dm2sp->ms_retries = 0;
return (0);
}
DTRACE_PROBE2(dm2s_mb_busy, dm2s_t, dm2sp, int, ret);
/*
* Queue it back, so that we can retry again.
*/
(void) putbq(wq, mp);
return (ret);
}
DMPBYTES("dm2s: Putmsg: ", len, numsg, dm2sp->ms_sg_tx);
dm2sp->ms_retries = 0;
freemsg(mp);
DPRINTF(DBG_DRV, ("dm2s_transmit: ret=%d\n", ret));
return (ret);
}
/*
* dm2s_bufcall_rcv - Bufcall callaback routine.
*
* It simply enables read side queue so that the service procedure
* can retry receive operation.
*/
void
dm2s_bufcall_rcv(void *arg)
{
dm2s_t *dm2sp = (dm2s_t *)arg;
DPRINTF(DBG_DRV, ("dm2s_bufcall_rcv: called\n"));
mutex_enter(&dm2sp->ms_lock);
dm2sp->ms_rbufcid = 0;
if (dm2sp->ms_rq != NULL) {
qenable(dm2sp->ms_rq);
}
mutex_exit(&dm2sp->ms_lock);
}
/*
* dm2s_rq_timeout - Timeout callback for the read side.
*
* It simply enables read side queue so that the service procedure
* can retry the receive operation.
*/
void
dm2s_rq_timeout(void *arg)
{
dm2s_t *dm2sp = (dm2s_t *)arg;
DPRINTF(DBG_DRV, ("dm2s_rq_timeout: called\n"));
mutex_enter(&dm2sp->ms_lock);
dm2sp->ms_rq_timeoutid = 0;
if (dm2sp->ms_rq != NULL) {
qenable(dm2sp->ms_rq);
}
mutex_exit(&dm2sp->ms_lock);
}
/*
* dm2s_wq_timeout - Timeout callback for the write.
*
* It simply enables write side queue so that the service procedure
* can retry the transmission operation.
*/
void
dm2s_wq_timeout(void *arg)
{
dm2s_t *dm2sp = (dm2s_t *)arg;
DPRINTF(DBG_DRV, ("dm2s_wq_timeout: called\n"));
mutex_enter(&dm2sp->ms_lock);
dm2sp->ms_wq_timeoutid = 0;
if (dm2sp->ms_wq != NULL) {
qenable(dm2sp->ms_wq);
}
mutex_exit(&dm2sp->ms_lock);
}
/*
* dm2s_prep_scatgath - Prepare scatter/gather elements for transmission
* of a streams message.
*/
static int
dm2s_prep_scatgath(mblk_t *mp, uint32_t *numsg, mscat_gath_t *sgp, int maxsg)
{
uint32_t num = 0;
mblk_t *tmp = mp;
while ((tmp != NULL) && (num < maxsg)) {
sgp[num].msc_dptr = (caddr_t)tmp->b_rptr;
sgp[num].msc_len = MBLKL(tmp);
tmp = tmp->b_cont;
num++;
}
if (tmp != NULL) {
/*
* Number of scatter/gather elements available are not
* enough, so lets pullup the msg.
*/
if (pullupmsg(mp, -1) != 1) {
return (EAGAIN);
}
sgp[0].msc_dptr = (caddr_t)mp->b_rptr;
sgp[0].msc_len = MBLKL(mp);
num = 1;
}
*numsg = num;
return (0);
}
/*
* dm2s_timeout_val -- Return appropriate timeout value.
*
* A small timeout value is returned for EBUSY and EAGAIN cases. This is
* because the condition is expected to be recovered sooner.
*
* A larger timeout value is returned for ENOSPC case, as the condition
* depends on the peer to release buffer space.
* NOTE: there will also be an event(SCF_MB_SPACE) but a timeout is
* used for reliability purposes.
*/
static clock_t
dm2s_timeout_val(int error)
{
clock_t tval;
ASSERT(error == EBUSY || error == ENOSPC || error == EAGAIN);
if (error == EBUSY || error == EAGAIN) {
tval = DM2S_SM_TOUT;
} else {
tval = DM2S_LG_TOUT;
}
return (drv_usectohz(tval));
}
#ifdef DEBUG
static void
dm2s_dump_bytes(char *str, uint32_t total_len,
uint32_t num_sg, mscat_gath_t *sgp)
{
int i, j;
int nsg;
int len, tlen = 0;
mscat_gath_t *tp;
uint8_t *datap;
#define BYTES_PER_LINE 20
char bytestr[BYTES_PER_LINE * 3 + 1];
uint32_t digest = 0;
if (!(dm2s_debug & DBG_MESG))
return;
ASSERT(num_sg != 0);
for (nsg = 0; (nsg < num_sg) && (tlen < total_len); nsg++) {
tp = &sgp[nsg];
datap = (uint8_t *)tp->msc_dptr;
len = tp->msc_len;
for (i = 0; i < len; i++) {
digest += datap[i];
}
tlen += len;
}
(void) sprintf(bytestr, "%s Packet: Size=%d Digest=%d\n",
str, total_len, digest);
DTRACE_PROBE1(dm2s_dump_digest, unsigned char *, bytestr);
tlen = 0;
for (nsg = 0; (nsg < num_sg) && (tlen < total_len); nsg++) {
tp = &sgp[nsg];
datap = (uint8_t *)tp->msc_dptr;
len = tp->msc_len;
for (i = 0; i < len; ) {
for (j = 0; (j < BYTES_PER_LINE) &&
(i < len); j++, i++) {
(void) sprintf(&bytestr[j * 3], "%02X ",
datap[i]);
digest += datap[i];
}
if (j != 0) {
DTRACE_PROBE1(dm2s_dump, unsigned char *,
bytestr);
}
}
tlen += i;
}
}
#endif /* DEBUG */