/*
 * 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) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 */


/*
 * sun4v domain services SNMP driver
 */

#include <sys/types.h>
#include <sys/file.h>
#include <sys/errno.h>
#include <sys/open.h>
#include <sys/cred.h>
#include <sys/uio.h>
#include <sys/stat.h>
#include <sys/ksynch.h>
#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/devops.h>
#include <sys/debug.h>
#include <sys/cmn_err.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ds.h>
#include <sys/ds_snmp.h>

#define	DS_SNMP_NAME		"ds_snmp"
#define	DS_SNMP_MAX_OPENS	256
#define	DS_BITS_IN_UINT64	64
#define	DS_MINOR_POOL_SZ	(DS_SNMP_MAX_OPENS / DS_BITS_IN_UINT64)
#define	DS_SNMP_MINOR_SHIFT	56
#define	DS_SNMP_DBG		if (ds_snmp_debug) printf

typedef	struct {
	uint64_t	seq_num;
	uint64_t	type;
} ds_snmp_msg_t;

typedef	enum {
	DS_SNMP_REQUEST	= 0,
	DS_SNMP_REPLY	= 1,
	DS_SNMP_ERROR = 2
} ds_snmp_msg_type_t;

typedef enum {
	DS_SNMP_READY = 0x0,
	DS_SNMP_REQUESTED = 0x1,
	DS_SNMP_DATA_AVL = 0x2,
	DS_SNMP_DATA_ERR = 0x3
} ds_snmp_flags_t;

/*
 * The single mutex 'lock' protects all the SNMP/DS variables in the state
 * structure.
 *
 * The condition variable 'state_cv' helps serialize write() calls for a
 * single descriptor. When write() is called, it sets a flag to indicate
 * that an SNMP request has been made to the agent. No more write()'s on
 * the same open descriptor will be allowed until this flag is cleared via
 * a matching read(), where the requested packet is consumed on arrival.
 * Read() then wakes up any waiters blocked in write() for sending the next
 * SNMP request to the agent.
 */
typedef struct ds_snmp_state {
	dev_info_t	*dip;
	int		instance;
	dev_t		dev;

	/* SNMP/DS */
	kmutex_t	lock;
	kcondvar_t	state_cv;
	ds_snmp_flags_t	state;
	void		*data;
	size_t		data_len;
	uint64_t	req_id;
	uint64_t	last_req_id;
	uint64_t	gencount;
	boolean_t	sc_reset;
} ds_snmp_state_t;


static uint_t		ds_snmp_debug = 0;
static void		*ds_snmp_statep = NULL;
static int		ds_snmp_instance = -1;
static dev_info_t	*ds_snmp_devi = NULL;

/*
 * The ds_snmp_lock mutex protects the following data global to the
 * driver.
 *
 * The ds_snmp_service_cv condition variable is used to resolve the
 * potential race between the registration of snmp service via a
 * ds_cap_init() in attach(), the acknowledgement of this registration
 * at a later time in ds_snmp_reg_handler(), and a possible open() at
 * a time inbetween. The ds_snmp_has_service and ds_snmp_handle are
 * used to indicate whether the registration acknowledgement has happened
 * or not.
 *
 * The ds_snmp_minor_pool[] is a bitmask to allocate and keep track of
 * minor numbers dynamically.
 */
static kmutex_t		ds_snmp_lock;
static kcondvar_t	ds_snmp_service_cv;
static int		ds_snmp_has_service = B_FALSE;
static ds_svc_hdl_t	ds_snmp_handle = DS_INVALID_HDL;
static uint64_t		ds_snmp_minor_pool[DS_MINOR_POOL_SZ];	/* bitmask */
static int		ds_snmp_num_opens = 0;

static int ds_snmp_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int ds_snmp_attach(dev_info_t *, ddi_attach_cmd_t);
static int ds_snmp_detach(dev_info_t *, ddi_detach_cmd_t);
static int ds_snmp_open(dev_t *, int, int, cred_t *);
static int ds_snmp_close(dev_t, int, int, cred_t *);
static int ds_snmp_read(dev_t, struct uio *, cred_t *);
static int ds_snmp_write(dev_t, struct uio *, cred_t *);
static int ds_snmp_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

/*
 * DS Callbacks
 */
static void ds_snmp_reg_handler(ds_cb_arg_t, ds_ver_t *, ds_svc_hdl_t);
static void ds_snmp_unreg_handler(ds_cb_arg_t arg);
static void ds_snmp_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen);

/*
 * SNMP DS capability registration
 */
static ds_ver_t ds_snmp_ver_1_0 = { 1, 0 };
static ds_capability_t ds_snmp_cap = {
	"snmp",
	&ds_snmp_ver_1_0,
	1
};

/*
 * SNMP DS Client callback vector
 */
static ds_clnt_ops_t ds_snmp_ops = {
	ds_snmp_reg_handler,	/* ds_reg_cb */
	ds_snmp_unreg_handler,	/* ds_unreg_cb */
	ds_snmp_data_handler,	/* ds_data_cb */
	NULL			/* cb_arg */
};

/*
 * DS SNMP driver Ops Vector
 */
static struct cb_ops ds_snmp_cb_ops = {
	ds_snmp_open,		/* cb_open */
	ds_snmp_close,		/* cb_close */
	nodev,			/* cb_strategy */
	nodev,			/* cb_print */
	nodev,			/* cb_dump */
	ds_snmp_read,		/* cb_read */
	ds_snmp_write,		/* cb_write */
	ds_snmp_ioctl,		/* cb_ioctl */
	nodev,			/* cb_devmap */
	nodev,			/* cb_mmap */
	nodev,			/* cb_segmap */
	nochpoll,		/* cb_chpoll */
	ddi_prop_op,		/* cb_prop_op */
	(struct streamtab *)NULL, /* cb_str */
	D_MP | D_64BIT,		/* cb_flag */
	CB_REV,			/* cb_rev */
	nodev,			/* cb_aread */
	nodev			/* cb_awrite */
};

static struct dev_ops ds_snmp_dev_ops = {
	DEVO_REV,		/* devo_rev */
	0,			/* devo_refcnt */
	ds_snmp_getinfo,	/* devo_getinfo */
	nulldev,		/* devo_identify */
	nulldev,		/* devo_probe */
	ds_snmp_attach,		/* devo_attach */
	ds_snmp_detach,		/* devo_detach */
	nodev,			/* devo_reset */
	&ds_snmp_cb_ops,	/* devo_cb_ops */
	(struct bus_ops *)NULL,	/* devo_bus_ops */
	nulldev,		/* devo_power */
	ddi_quiesce_not_needed,		/* devo_quiesce */
};

static struct modldrv modldrv = {
	&mod_driverops,
	"Domain Services SNMP Driver",
	&ds_snmp_dev_ops
};

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

int
_init(void)
{
	int retval;

	mutex_init(&ds_snmp_lock, NULL, MUTEX_DRIVER, NULL);
	cv_init(&ds_snmp_service_cv, NULL, CV_DRIVER, NULL);

	retval = ddi_soft_state_init(&ds_snmp_statep,
	    sizeof (ds_snmp_state_t), DS_SNMP_MAX_OPENS);
	if (retval != 0) {
		cv_destroy(&ds_snmp_service_cv);
		mutex_destroy(&ds_snmp_lock);
		return (retval);
	}

	retval = mod_install(&modlinkage);
	if (retval != 0) {
		ddi_soft_state_fini(&ds_snmp_statep);
		cv_destroy(&ds_snmp_service_cv);
		mutex_destroy(&ds_snmp_lock);
	}

	return (retval);
}

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

int
_fini(void)
{
	int retval;

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

	ddi_soft_state_fini(&ds_snmp_statep);

	cv_destroy(&ds_snmp_service_cv);
	mutex_destroy(&ds_snmp_lock);

	return (retval);
}

/*ARGSUSED*/
static int
ds_snmp_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
{
	ds_snmp_state_t *sp;
	int retval = DDI_FAILURE;

	ASSERT(resultp != NULL);

	switch (cmd) {
	case DDI_INFO_DEVT2DEVINFO:
		sp = ddi_get_soft_state(ds_snmp_statep, getminor((dev_t)arg));
		if (sp != NULL) {
			*resultp = sp->dip;
			retval = DDI_SUCCESS;
		} else
			*resultp = NULL;
		break;

	case DDI_INFO_DEVT2INSTANCE:
		*resultp = (void *)(uintptr_t)getminor((dev_t)arg);
		retval = DDI_SUCCESS;
		break;
	}

	return (retval);
}

static int
ds_snmp_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int	rv;

	switch (cmd) {
	case DDI_ATTACH:
		if (ds_snmp_instance != -1)
			return (DDI_FAILURE);
		break;

	case DDI_RESUME:
		return (DDI_SUCCESS);

	default:
		return (DDI_FAILURE);
	}

	ds_snmp_instance = ddi_get_instance(dip);
	if (ddi_create_minor_node(dip, DS_SNMP_NAME, S_IFCHR, ds_snmp_instance,
	    DDI_PSEUDO, 0) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "%s@%d: Unable to create minor node",
		    DS_SNMP_NAME, ds_snmp_instance);
		return (DDI_FAILURE);
	}

	bzero(ds_snmp_minor_pool, DS_MINOR_POOL_SZ * sizeof (uint64_t));

	ds_snmp_ops.cb_arg = dip;
	if ((rv = ds_cap_init(&ds_snmp_cap, &ds_snmp_ops)) != 0) {
		cmn_err(CE_NOTE, "ds_cap_init failed: %d", rv);
		ddi_remove_minor_node(dip, NULL);
		ds_snmp_instance = -1;
		return (DDI_FAILURE);
	}

	ds_snmp_devi = dip;
	ddi_report_dev(dip);

	return (DDI_SUCCESS);
}

/*ARGSUSED*/
static int
ds_snmp_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_DETACH:
		if (ds_snmp_instance == -1)
			return (DDI_FAILURE);
		break;

	case DDI_SUSPEND:
		return (DDI_SUCCESS);

	default:
		return (DDI_FAILURE);
	}

	(void) ds_cap_fini(&ds_snmp_cap);

	ddi_remove_minor_node(ds_snmp_devi, NULL);
	bzero(ds_snmp_minor_pool, DS_MINOR_POOL_SZ * sizeof (uint64_t));

	ds_snmp_instance = -1;
	ds_snmp_devi = NULL;

	return (DDI_SUCCESS);
}

static minor_t
ds_snmp_get_minor(void)
{
	uint64_t	val;
	int		i, ndx;
	minor_t		minor;

	mutex_enter(&ds_snmp_lock);
	for (ndx = 0; ndx < DS_MINOR_POOL_SZ; ndx++) {
		val = ds_snmp_minor_pool[ndx];
		for (i = 0; i < DS_BITS_IN_UINT64; i++) {
			if ((val & 0x1) == 0) {
				ds_snmp_minor_pool[ndx] |= ((uint64_t)1 << i);
				ds_snmp_num_opens++;
				mutex_exit(&ds_snmp_lock);

				minor = ndx * DS_BITS_IN_UINT64 + i + 1;

				return (minor);
			}
			val >>= 1;
		}
	}
	mutex_exit(&ds_snmp_lock);

	return (0);
}

static void
ds_snmp_rel_minor(minor_t minor)
{
	int	i, ndx;

	ndx = (minor - 1) / DS_BITS_IN_UINT64;
	i = (minor - 1) % DS_BITS_IN_UINT64;

	ASSERT(ndx < DS_MINOR_POOL_SZ);

	mutex_enter(&ds_snmp_lock);

	ds_snmp_num_opens--;
	ds_snmp_minor_pool[ndx] &= ~((uint64_t)1 << i);

	mutex_exit(&ds_snmp_lock);
}

static boolean_t
ds_snmp_is_open(minor_t minor)
{
	uint64_t	val;
	int		i, ndx;

	ndx = (minor - 1) / DS_BITS_IN_UINT64;
	i = (minor - 1) % DS_BITS_IN_UINT64;

	val = ((uint64_t)1 << i);
	if (ds_snmp_minor_pool[ndx] & val)
		return (B_TRUE);
	else
		return (B_FALSE);
}

static int
ds_snmp_create_state(dev_t *devp)
{
	major_t	major;
	minor_t	minor;
	ds_snmp_state_t	*sp;

	if ((minor = ds_snmp_get_minor()) == 0)
		return (EMFILE);

	if (ddi_soft_state_zalloc(ds_snmp_statep, minor) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "%s@%d: Unable to allocate state",
		    DS_SNMP_NAME, minor);
		ds_snmp_rel_minor(minor);
		return (ENOMEM);
	}

	sp = ddi_get_soft_state(ds_snmp_statep, minor);
	if (devp != NULL)
		major = getemajor(*devp);
	else
		major = ddi_driver_major(ds_snmp_devi);

	sp->dev = makedevice(major, minor);
	if (devp != NULL)
		*devp = sp->dev;

	sp->instance = minor;
	sp->data = NULL;
	sp->data_len = 0;
	sp->req_id = 0;
	sp->last_req_id = 0;
	sp->state = DS_SNMP_READY;
	sp->sc_reset = B_FALSE;

	mutex_init(&sp->lock, NULL, MUTEX_DRIVER, NULL);
	cv_init(&sp->state_cv, NULL, CV_DRIVER, NULL);

	return (0);
}

static int
ds_snmp_destroy_state(dev_t dev)
{
	ds_snmp_state_t	*sp;
	minor_t	minor;

	minor = getminor(dev);

	if ((sp = ddi_get_soft_state(ds_snmp_statep, minor)) == NULL)
		return (ENXIO);

	ASSERT(sp->instance == minor);

	/*
	 * If the app has not exited cleanly, the data may not have been
	 * read/memory freed, hence take care of that here
	 */
	if (sp->data) {
		kmem_free(sp->data, sp->data_len);
	}
	cv_destroy(&sp->state_cv);
	mutex_destroy(&sp->lock);

	ddi_soft_state_free(ds_snmp_statep, minor);
	ds_snmp_rel_minor(minor);

	return (0);
}

/*ARGSUSED*/
static int
ds_snmp_open(dev_t *devp, int flag, int otyp, cred_t *credp)
{

	if (otyp != OTYP_CHR)
		return (EINVAL);

	if (ds_snmp_instance == -1)
		return (ENXIO);

	/*
	 * Avoid possible race condition - ds service may not be there yet
	 */
	mutex_enter(&ds_snmp_lock);
	while (ds_snmp_has_service == B_FALSE) {
		if (cv_wait_sig(&ds_snmp_service_cv, &ds_snmp_lock) == 0) {
			mutex_exit(&ds_snmp_lock);
			return (EINTR);
		}
	}
	mutex_exit(&ds_snmp_lock);

	return (ds_snmp_create_state(devp));
}


/*ARGSUSED*/
static int
ds_snmp_close(dev_t dev, int flag, int otyp, cred_t *credp)
{
	if (otyp != OTYP_CHR)
		return (EINVAL);

	if (ds_snmp_instance == -1)
		return (ENXIO);

	if (ds_snmp_handle == DS_INVALID_HDL)
		return (EIO);

	return (ds_snmp_destroy_state(dev));
}

/*ARGSUSED*/
static int
ds_snmp_read(dev_t dev, struct uio *uiop, cred_t *credp)
{
	ds_snmp_state_t *sp;
	minor_t	minor;
	size_t len;
	int retval;
	caddr_t tmpbufp = (caddr_t)NULL;

	/*
	 * Given that now we can have sc resets happening at any
	 * time, it is possible that it happened since the last time
	 * we issued a read, write or ioctl.  If so, we need to wait
	 * for the unreg-reg pair to complete before we can do
	 * anything.
	 */
	mutex_enter(&ds_snmp_lock);
	while (ds_snmp_has_service == B_FALSE) {
		DS_SNMP_DBG("ds_snmp_read: waiting for service\n");
		if (cv_wait_sig(&ds_snmp_service_cv, &ds_snmp_lock) == 0) {
			mutex_exit(&ds_snmp_lock);
			return (EINTR);
		}
	}
	mutex_exit(&ds_snmp_lock);

	if ((len = uiop->uio_resid) == 0)
		return (0);

	minor = getminor(dev);
	if ((sp = ddi_get_soft_state(ds_snmp_statep, minor)) == NULL)
		return (ENXIO);

	mutex_enter(&sp->lock);

	if (sp->sc_reset == B_TRUE) {
		mutex_exit(&sp->lock);
		return (ECANCELED);
	}

	/*
	 * Block or bail if there is no SNMP data
	 */
	if (sp->state != DS_SNMP_DATA_AVL && sp->state != DS_SNMP_DATA_ERR) {
		DS_SNMP_DBG("ds_snmp_read: no SNMP data\n");
		if (uiop->uio_fmode & (FNDELAY | FNONBLOCK)) {
			mutex_exit(&sp->lock);
			return (EAGAIN);
		}
		while (sp->state != DS_SNMP_DATA_AVL &&
		    sp->state != DS_SNMP_DATA_ERR) {
			if (cv_wait_sig(&sp->state_cv, &sp->lock) == 0) {
				mutex_exit(&sp->lock);
				return (EINTR);
			}
		}
	}

	/*
	 * If there has been an error, it could be because the agent
	 * returned failure and there is no data to read, or an ldc-reset
	 * has happened.  Figure out which and return appropriate
	 * error to the caller.
	 */
	if (sp->state == DS_SNMP_DATA_ERR) {
		if (sp->sc_reset == B_TRUE) {
			mutex_exit(&sp->lock);
			DS_SNMP_DBG("ds_snmp_read: sc got reset, "
			    "returning ECANCELED\n");
			return (ECANCELED);
		} else {
			sp->state = DS_SNMP_READY;
			cv_broadcast(&sp->state_cv);
			mutex_exit(&sp->lock);
			DS_SNMP_DBG("ds_snmp_read: data error, "
			    "returning EIO\n");
			return (EIO);
		}
	}

	if (len > sp->data_len)
		len = sp->data_len;

	tmpbufp = kmem_alloc(len, KM_SLEEP);

	bcopy(sp->data, (void *)tmpbufp, len);
	kmem_free(sp->data, sp->data_len);
	sp->data = (caddr_t)NULL;
	sp->data_len = 0;

	/*
	 * SNMP data has been consumed, wake up anyone waiting to send
	 */
	sp->state = DS_SNMP_READY;
	cv_broadcast(&sp->state_cv);

	mutex_exit(&sp->lock);

	retval = uiomove(tmpbufp, len, UIO_READ, uiop);
	kmem_free(tmpbufp, len);

	return (retval);
}

/*ARGSUSED*/
static int
ds_snmp_write(dev_t dev, struct uio *uiop, cred_t *credp)
{
	ds_snmp_state_t *sp;
	ds_snmp_msg_t hdr;
	minor_t minor;
	size_t len;
	caddr_t tmpbufp;
	size_t orig_size;

	/*
	 * Check if there was an sc reset; if yes, wait until we have the
	 * service back again.
	 */
	mutex_enter(&ds_snmp_lock);
	while (ds_snmp_has_service == B_FALSE) {
		DS_SNMP_DBG("ds_snmp_write: waiting for service\n");
		if (cv_wait_sig(&ds_snmp_service_cv, &ds_snmp_lock) == 0) {
			mutex_exit(&ds_snmp_lock);
			return (EINTR);
		}
	}
	mutex_exit(&ds_snmp_lock);

	minor = getminor(dev);
	if ((sp = ddi_get_soft_state(ds_snmp_statep, minor)) == NULL)
		return (ENXIO);

	orig_size = uiop->uio_resid;
	len = uiop->uio_resid + sizeof (ds_snmp_msg_t);
	tmpbufp = kmem_alloc(len, KM_SLEEP);

	if (uiomove(tmpbufp + sizeof (ds_snmp_msg_t),
	    len - sizeof (ds_snmp_msg_t), UIO_WRITE, uiop) != 0) {
		kmem_free(tmpbufp, len);
		return (EIO);
	}

	mutex_enter(&sp->lock);

	if (sp->sc_reset == B_TRUE) {
		mutex_exit(&sp->lock);
		kmem_free(tmpbufp, len);
		DS_SNMP_DBG("ds_snmp_write: sc_reset is TRUE, "
		    "returning ECANCELD\n");
		return (ECANCELED);
	}

	/*
	 * wait if earlier transaction is not yet completed
	 */
	while (sp->state != DS_SNMP_READY) {
		if (cv_wait_sig(&sp->state_cv, &sp->lock) == 0) {
			mutex_exit(&sp->lock);
			kmem_free(tmpbufp, len);
			uiop->uio_resid = orig_size;
			return (EINTR);
		}
		/*
		 * Normally, only a reader would ever wake us up. But if we
		 * did get signalled with an ERROR, it could only mean there
		 * was an sc reset and there's no point waiting; we need to
		 * fail this write().
		 */
		if (sp->state == DS_SNMP_DATA_ERR && sp->sc_reset == B_TRUE) {
			DS_SNMP_DBG("ds_snmp_write: woke up with an sc_reset, "
			    "returning ECANCELED\n");
			mutex_exit(&sp->lock);
			kmem_free(tmpbufp, len);
			return (ECANCELED);
		}
	}

	if (sp->req_id == (((uint64_t)1 << DS_SNMP_MINOR_SHIFT) - 1))
		sp->req_id = 0; /* Reset */

	hdr.seq_num = ((uint64_t)minor << DS_SNMP_MINOR_SHIFT) | sp->req_id;
	sp->last_req_id = hdr.seq_num;
	(sp->req_id)++;

	/*
	 * Set state to SNMP_REQUESTED, but don't wakeup anyone yet
	 */
	sp->state = DS_SNMP_REQUESTED;

	mutex_exit(&sp->lock);

	hdr.type = DS_SNMP_REQUEST;
	bcopy((void *)&hdr, (void *)tmpbufp, sizeof (hdr));

	/*
	 * If the service went away since the time we entered this
	 * routine and now, tough luck. Just ignore the current
	 * write() and return.
	 */
	mutex_enter(&ds_snmp_lock);
	if (ds_snmp_has_service == B_FALSE) {
		DS_SNMP_DBG("ds_snmp_write: service went away, aborting "
		    "write, returning ECANCELED\n");
		mutex_exit(&ds_snmp_lock);
		kmem_free(tmpbufp, len);
		return (ECANCELED);
	}
	DS_SNMP_DBG("ds_snmp_write: ds_cap_send(0x%lx, %lu) called.\n",
	    ds_snmp_handle, len);
	(void) ds_cap_send(ds_snmp_handle, tmpbufp, len);
	mutex_exit(&ds_snmp_lock);

	kmem_free(tmpbufp, len);

	return (0);
}

/*ARGSUSED*/
static int
ds_snmp_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
	ds_snmp_state_t *sp;
	struct dssnmp_info info;
	minor_t	minor;

	/*
	 * Check if there was an sc reset; if yes, wait until we have the
	 * service back again.
	 */
	mutex_enter(&ds_snmp_lock);
	while (ds_snmp_has_service == B_FALSE) {
		DS_SNMP_DBG("ds_snmp_ioctl: waiting for service\n");
		if (cv_wait_sig(&ds_snmp_service_cv, &ds_snmp_lock) == 0) {
			mutex_exit(&ds_snmp_lock);
			return (EINTR);
		}
	}
	mutex_exit(&ds_snmp_lock);

	DS_SNMP_DBG("ds_snmp_ioctl: hdl=0x%lx\n", ds_snmp_handle);

	minor = getminor(dev);
	if ((sp = ddi_get_soft_state(ds_snmp_statep, minor)) == NULL)
		return (ENXIO);

	if (!(mode & FREAD))
		return (EACCES);

	switch (cmd) {
	case DSSNMP_GETINFO:
		mutex_enter(&sp->lock);

		if (sp->sc_reset == B_TRUE) {
			mutex_exit(&sp->lock);
			DS_SNMP_DBG("ds_snmp_ioctl: returning ECANCELED\n");
			return (ECANCELED);
		}

		while (sp->state != DS_SNMP_DATA_AVL &&
		    sp->state != DS_SNMP_DATA_ERR) {
			DS_SNMP_DBG("ds_snmp_ioctl: state=%d, sc_reset=%d, "
			    "waiting for data\n", sp->state, sp->sc_reset);
			if (cv_wait_sig(&sp->state_cv, &sp->lock) == 0) {
				sp->state = DS_SNMP_READY;
				mutex_exit(&sp->lock);
				return (EINTR);
			}
		}
		DS_SNMP_DBG("ds_snmp_ioctl: state=%d, sc_reset=%d, "
		    "out of wait!\n", sp->state, sp->sc_reset);

		/*
		 * If there has been an error, it could be because the
		 * agent returned failure and there is no data to read,
		 * or an ldc-reset has happened.  Figure out which and
		 * return appropriate error to the caller.
		 */
		if (sp->state == DS_SNMP_DATA_ERR) {
			if (sp->sc_reset == B_TRUE) {
				mutex_exit(&sp->lock);
				DS_SNMP_DBG("ds_snmp_ioctl: sc_reset=TRUE "
				    "returning ECANCELED\n");
				return (ECANCELED);
			} else {
				sp->state = DS_SNMP_READY;
				cv_broadcast(&sp->state_cv);
				mutex_exit(&sp->lock);
				DS_SNMP_DBG("ds_snmp_ioctl: sc_reset=FALSE "
				    "returning EIO\n");
				return (EIO);
			}
		}

		info.size = sp->data_len;
		info.token = sp->gencount;

		mutex_exit(&sp->lock);

		if (ddi_copyout(&info, (void *)arg, sizeof (info), mode) != 0)
			return (EFAULT);
		break;

	case DSSNMP_CLRLNKRESET:
		mutex_enter(&sp->lock);

		DS_SNMP_DBG("ds_snmp_ioctl: DSSNMP_CLRLNKRESET\n");
		DS_SNMP_DBG("ds_snmp_ioctl: sc_reset=%d\n", sp->sc_reset);

		if (sp->sc_reset == B_TRUE) {
			if (sp->data) {
				DS_SNMP_DBG("ds_snmp_ioctl: data=%p, len=%lu\n",
				    sp->data, sp->data_len);
				kmem_free(sp->data, sp->data_len);
			}
			sp->data = NULL;
			sp->data_len = 0;
			sp->state = DS_SNMP_READY;
			sp->req_id = 0;
			sp->last_req_id = 0;
			sp->sc_reset = B_FALSE;
		}
		mutex_exit(&sp->lock);
		break;

	default:
		return (ENOTTY);
	}

	return (0);
}

/*
 * DS Callbacks
 */
/*ARGSUSED*/
static void
ds_snmp_reg_handler(ds_cb_arg_t arg, ds_ver_t *ver, ds_svc_hdl_t hdl)
{
	DS_SNMP_DBG("ds_snmp_reg_handler: registering handle 0x%lx for version "
	    "0x%x:0x%x\n", (uint64_t)hdl, ver->major, ver->minor);

	mutex_enter(&ds_snmp_lock);

	ASSERT(ds_snmp_handle == DS_INVALID_HDL);

	ds_snmp_handle = hdl;
	ds_snmp_has_service = B_TRUE;

	cv_broadcast(&ds_snmp_service_cv);

	mutex_exit(&ds_snmp_lock);

}

/*ARGSUSED*/
static void
ds_snmp_unreg_handler(ds_cb_arg_t arg)
{
	minor_t minor;
	ds_snmp_state_t *sp;

	DS_SNMP_DBG("ds_snmp_unreg_handler: un-registering ds_snmp service\n");

	mutex_enter(&ds_snmp_lock);

	if (ds_snmp_num_opens) {
		DS_SNMP_DBG("ds_snmp_unreg_handler: %d opens, sc reset!\n",
		    ds_snmp_num_opens);
		for (minor = 1; minor <= DS_SNMP_MAX_OPENS; minor++) {
			if (ds_snmp_is_open(minor)) {
				DS_SNMP_DBG("ds_snmp_unreg_handler: minor %d "
				    "open\n", minor);
				sp = ddi_get_soft_state(ds_snmp_statep, minor);
				if (sp == NULL)
					continue;

				/*
				 * Set the sc_reset flag and break any waiters
				 * out of their existing reads/writes/ioctls.
				 */
				DS_SNMP_DBG("ds_snmp_unreg_hdlr: about to "
				    "signal waiters\n");
				mutex_enter(&sp->lock);
				sp->sc_reset = B_TRUE;
				sp->state = DS_SNMP_DATA_ERR;
				cv_broadcast(&sp->state_cv);
				mutex_exit(&sp->lock);
			}
		}
	}

	ds_snmp_handle = DS_INVALID_HDL;
	ds_snmp_has_service = B_FALSE;

	DS_SNMP_DBG("ds_snmp_unreg_handler: handle invalidated\n");

	mutex_exit(&ds_snmp_lock);
}

/*ARGSUSED*/
static void
ds_snmp_data_handler(ds_cb_arg_t arg, void *buf, size_t buflen)
{
	ds_snmp_state_t *sp;
	ds_snmp_msg_t   hdr;
	size_t  	snmp_size;
	minor_t 	minor;

	/*
	 * Make sure the header is at least valid
	 */
	if (buflen < sizeof (hdr)) {
		cmn_err(CE_WARN,
		"ds_snmp_data_handler: buflen <%lu> too small", buflen);
		return;
	}

	ASSERT(buf != NULL);
	bcopy(buf, (void *)&hdr, sizeof (hdr));

	DS_SNMP_DBG("ds_snmp_data_handler: msg buf len 0x%lx : type 0x%lx, "
	    "seqn 0x%lx\n", buflen, hdr.type, hdr.seq_num);

	minor = (int)(hdr.seq_num >> DS_SNMP_MINOR_SHIFT);
	if ((sp = ddi_get_soft_state(ds_snmp_statep, minor)) == NULL)
		return;

	mutex_enter(&sp->lock);

	/*
	 * If there is no pending SNMP request, then we've received
	 * bogus data or an SNMP trap or the reader was interrupted.
	 * Since we don't yet support SNMP traps, ignore it.
	 */
	if (sp->state != DS_SNMP_REQUESTED) {
		DS_SNMP_DBG("Received SNMP data without request");
		mutex_exit(&sp->lock);
		return;
	}

	/*
	 * Response to a request therefore old SNMP must've been consumed
	 */
	ASSERT(sp->data_len == 0);
	ASSERT(sp->data == NULL);

	/*
	 * Response seq_num should match our request seq_num
	 */
	if (hdr.seq_num != sp->last_req_id) {
		cmn_err(CE_WARN, "Received DS snmp data out of sequence with "
		    "request");
		mutex_exit(&sp->lock);
		return;
	}

	if (hdr.type == DS_SNMP_ERROR) {
		sp->state = DS_SNMP_DATA_ERR;
		DS_SNMP_DBG("ds_snmp_data_handler: hdr.type = DS_SNMP_ERROR\n");
	} else {
		snmp_size = buflen - sizeof (ds_snmp_msg_t);
		sp->data = kmem_alloc(snmp_size, KM_SLEEP);
		sp->data_len = snmp_size;
		sp->state = DS_SNMP_DATA_AVL;

		bcopy((caddr_t)buf + sizeof (ds_snmp_msg_t),
		    sp->data, sp->data_len);
	}

	sp->gencount++;

	/*
	 * Wake up any readers waiting for data
	 */
	cv_broadcast(&sp->state_cv);
	mutex_exit(&sp->lock);
}