usr/src/uts/common/inet/dlpistub/dlpistub.c

/*
 * 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.
 */

/*
 * DLPI stub driver; currently supports VNI and IPMP stub devices.
 */

#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/dlpi.h>
#include <sys/stat.h>
#include <sys/strsun.h>
#include <sys/stropts.h>
#include <sys/types.h>
#include <sys/id_space.h>
#include <sys/sysmacros.h>
#include <sys/kmem.h>
#include <sys/modctl.h>
#include <sys/mkdev.h>
#include <sys/sdt.h>

#include "dlpistub_impl.h"

static id_space_t *ds_minors;
static dev_info_t *ds_dip;

/*
 * DL_INFO_ACK template.
 */
static dl_info_ack_t ds_infoack = {
	DL_INFO_ACK,	/* dl_primitive */
	0,		/* dl_max_sdu */
	0,		/* dl_min_sdu */
	0,		/* dl_addr_length */
	0,		/* dl_mac_type */
	0,		/* dl_reserved */
	0,		/* dl_current_state */
	0,		/* dl_sap_length */
	DL_CLDLS,	/* dl_service_mode */
	0,		/* dl_qos_length */
	0,		/* dl_qos_offset */
	0,		/* dl_qos_range_length */
	0,		/* dl_qos_range_offset */
	DL_STYLE2,	/* dl_provider_style */
	0,		/* dl_addr_offset */
	DL_VERSION_2,	/* dl_version */
	0,		/* dl_brdcst_addr_length */
	0,		/* dl_brdcst_addr_offset */
	0		/* dl_growth */
};

static int
ds_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	if (cmd != DDI_ATTACH)
		return (DDI_FAILURE);

	if (ddi_create_minor_node(dip, "vni", S_IFCHR, DS_MINOR_VNI,
	    DDI_PSEUDO, 0) == DDI_FAILURE ||
	    ddi_create_minor_node(dip, "ipmpstub", S_IFCHR, DS_MINOR_IPMP,
	    DDI_PSEUDO, 0) == DDI_FAILURE) {
		ddi_remove_minor_node(dip, NULL);
		cmn_err(CE_NOTE, "ds_attach: cannot create minor nodes");
		return (DDI_FAILURE);
	}

	ds_dip = dip;
	ds_minors = id_space_create("ds_minors", DS_MINOR_START, MAXMIN32);
	return (DDI_SUCCESS);
}

static int
ds_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	if (cmd != DDI_DETACH)
		return (DDI_FAILURE);

	id_space_destroy(ds_minors);
	ds_minors = NULL;
	ASSERT(dip == ds_dip);
	ddi_remove_minor_node(dip, NULL);
	ds_dip = NULL;
	return (DDI_SUCCESS);
}

/* ARGSUSED */
static int
ds_devinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
	int error = DDI_FAILURE;

	switch (infocmd) {
	case DDI_INFO_DEVT2INSTANCE:
		*result = (void *)0;
		error = DDI_SUCCESS;
		break;
	case DDI_INFO_DEVT2DEVINFO:
		if (ds_dip != NULL) {
			*result = ds_dip;
			error = DDI_SUCCESS;
		}
		break;
	}
	return (error);
}

/* ARGSUSED */
static int
ds_open(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *credp)
{
	int type;
	dlpistub_t *dsp;

	if (sflag == CLONEOPEN || sflag == MODOPEN)
		return (EINVAL);

	if (q->q_ptr != NULL)
		return (0);

	switch (getminor(*devp)) {
	case DS_MINOR_VNI:
		type = SUNW_DL_VNI;
		break;
	case DS_MINOR_IPMP:
		type = SUNW_DL_IPMP;
		break;
	default:
		return (ENXIO);
	}

	dsp = kmem_zalloc(sizeof (dlpistub_t), KM_SLEEP);
	dsp->ds_type = type;
	dsp->ds_minor = (minor_t)id_alloc(ds_minors);
	dsp->ds_state = DL_UNATTACHED;
	*devp = makedevice(getmajor(*devp), dsp->ds_minor);
	q->q_ptr = WR(q)->q_ptr = dsp;
	qprocson(q);

	return (0);
}

/* ARGSUSED */
static int
ds_close(queue_t *q, int flag, cred_t *credp)
{
	dlpistub_t	*dsp = q->q_ptr;

	qprocsoff(q);
	q->q_ptr = WR(q)->q_ptr = NULL;

	id_free(ds_minors, dsp->ds_minor);
	kmem_free(dsp, sizeof (dlpistub_t));

	return (0);
}

static int
ds_badprim(queue_t *q, mblk_t *mp, t_scalar_t prim)
{
	dlerrorack(q, mp, prim, DL_BADPRIM, 0);
	return (0);
}

static int
ds_outstate(queue_t *q, mblk_t *mp, t_scalar_t prim)
{
	dlerrorack(q, mp, prim, DL_OUTSTATE, 0);
	return (0);
}

static int
ds_wput(queue_t *q, mblk_t *mp)
{
	union DL_primitives	*dlp;
	dl_info_ack_t		*dlip;
	dlpistub_t		*dsp = q->q_ptr;
	t_scalar_t		prim;

	switch (DB_TYPE(mp)) {
	case M_PROTO:
	case M_PCPROTO:
		if (MBLKL(mp) < sizeof (t_scalar_t)) {
			dlerrorack(q, mp, DL_PRIM_INVAL, DL_UNSUPPORTED, 0);
			return (0);
		}

		dlp = (void *)mp->b_rptr;
		prim = dlp->dl_primitive;
		switch (prim) {
		case DL_ATTACH_REQ:
			if (MBLKL(mp) < DL_ATTACH_REQ_SIZE)
				return (ds_badprim(q, mp, prim));

			if (dsp->ds_state != DL_UNATTACHED)
				return (ds_outstate(q, mp, prim));

			dsp->ds_state = DL_UNBOUND;
			dlokack(q, mp, DL_ATTACH_REQ);
			break;

		case DL_BIND_REQ:
			if (MBLKL(mp) < DL_BIND_REQ_SIZE)
				return (ds_badprim(q, mp, prim));

			if (dsp->ds_state != DL_UNBOUND)
				return (ds_outstate(q, mp, prim));

			dsp->ds_state = DL_IDLE;
			dlbindack(q, mp, dlp->bind_req.dl_sap, NULL, 0, 0, 0);
			break;

		case DL_INFO_REQ:
			if (MBLKL(mp) < DL_INFO_REQ_SIZE)
				return (ds_badprim(q, mp, prim));

			mp = mexchange(q, mp, sizeof (dl_info_ack_t),
			    M_PCPROTO, DL_INFO_ACK);
			if (mp != NULL) {
				dlip = (void *)mp->b_rptr;
				*dlip = ds_infoack;
				dlip->dl_mac_type = dsp->ds_type;
				dlip->dl_current_state = dsp->ds_state;
				qreply(q, mp);
			}
			break;

		case DL_PHYS_ADDR_REQ:
			if (MBLKL(mp) < DL_PHYS_ADDR_REQ_SIZE)
				return (ds_badprim(q, mp, prim));

			dlphysaddrack(q, mp, NULL, 0);
			break;

		case DL_UNBIND_REQ:
			if (MBLKL(mp) < DL_UNBIND_REQ_SIZE)
				return (ds_badprim(q, mp, prim));

			if (dsp->ds_state != DL_IDLE)
				return (ds_outstate(q, mp, prim));

			dsp->ds_state = DL_UNBOUND;
			dlokack(q, mp, DL_UNBIND_REQ);
			break;

		case DL_DETACH_REQ:
			if (MBLKL(mp) < DL_DETACH_REQ_SIZE)
				return (ds_badprim(q, mp, prim));

			if (dsp->ds_state != DL_UNBOUND)
				return (ds_outstate(q, mp, prim));

			dsp->ds_state = DL_UNATTACHED;
			dlokack(q, mp, DL_DETACH_REQ);
			break;

		case DL_UNITDATA_REQ:
			DTRACE_PROBE2(dlpistub__data, dlpistub_t *, dsp,
			    mblk_t *, mp);
			freemsg(mp);
			break;

		default:
			dlerrorack(q, mp, prim, DL_UNSUPPORTED, 0);
		}
		break;

	case M_IOCTL:
		miocnak(q, mp, 0, EINVAL);
		break;

	case M_FLUSH:
		*mp->b_rptr &= ~FLUSHW;
		if (*mp->b_rptr & FLUSHR)
			qreply(q, mp);
		else
			freemsg(mp);
		break;
	default:
		freemsg(mp);
		break;
	}

	return (0);
}

static struct module_info ds_minfo = {
	DS_IDNUM,	/* mi_idnum */
	"dlpistub",	/* mi_idname */
	0,		/* mi_minpsz */
	INFPSZ,		/* mi_maxpsz */
	0,		/* mi_hiwat */
	0,		/* mi_lowat */
};

static struct qinit ds_rinit = {
	NULL,		/* qi_putp */
	NULL,		/* qi_srvp */
	ds_open,	/* qi_qopen */
	ds_close,	/* qi_qclose */
	NULL,		/* qi_qadmin */
	&ds_minfo,	/* qi_minfo */
};

static struct qinit ds_winit = {
	ds_wput,	/* qi_putp */
	NULL,		/* qi_srvp */
	NULL,		/* qi_qopen */
	NULL,		/* qi_qclose */
	NULL,		/* qi_qadmin */
	&ds_minfo,	/* qi_minfo */
};

static struct streamtab ds_info = {
	&ds_rinit,	/* st_rdinit */
	&ds_winit	/* st_wrinit */
};

DDI_DEFINE_STREAM_OPS(ds_ops, nulldev, nulldev, ds_attach, ds_detach,
    nodev, ds_devinfo, D_MP|D_MTPERMOD, &ds_info, ddi_quiesce_not_supported);

static struct modldrv modldrv = {
	&mod_driverops,
	"DLPI stub driver",
	&ds_ops,
};

static struct modlinkage modlinkage = {
	MODREV_1, &modldrv, NULL
};

int
_init(void)
{
	return (mod_install(&modlinkage));
}

int
_fini(void)
{
	return (mod_remove(&modlinkage));
}

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