inet/dlpistub/dlpistub.c

	dlpistub.c revision e11c3f44f531fdff80941ce57c065d2ae861cefc
/*
 * 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));
}