/*
 * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2023 Oxide Computer Company
 */

/*
 * Data-Link Driver
 */

#include        <inet/common.h>
#include        <sys/strsubr.h>
#include        <sys/stropts.h>
#include        <sys/strsun.h>
#include        <sys/vlan.h>
#include        <sys/dld_impl.h>
#include        <sys/cpuvar.h>
#include        <sys/callb.h>
#include        <sys/list.h>
#include        <sys/mac_client.h>
#include        <sys/mac_client_priv.h>
#include        <sys/mac_flow.h>

static int      str_constructor(void *, void *, int);
static void     str_destructor(void *, void *);
static mblk_t   *str_unitdata_ind(dld_str_t *, mblk_t *, boolean_t);
static void     str_notify_promisc_on_phys(dld_str_t *);
static void     str_notify_promisc_off_phys(dld_str_t *);
static void     str_notify_phys_addr(dld_str_t *, uint_t, const uint8_t *);
static void     str_notify_link_up(dld_str_t *);
static void     str_notify_link_down(dld_str_t *);
static void     str_notify_capab_reneg(dld_str_t *);
static void     str_notify_speed(dld_str_t *, uint32_t);

static void     ioc_native(dld_str_t *,  mblk_t *);
static void     ioc_margin(dld_str_t *, mblk_t *);
static void     ioc_raw(dld_str_t *, mblk_t *);
static void     ioc_fast(dld_str_t *,  mblk_t *);
static void     ioc_lowlink(dld_str_t *,  mblk_t *);
static void     ioc(dld_str_t *, mblk_t *);
static void     dld_ioc(dld_str_t *, mblk_t *);
static void     dld_wput_nondata(dld_str_t *, mblk_t *);

static void     str_mdata_raw_put(dld_str_t *, mblk_t *);
static mblk_t   *i_dld_ether_header_update_tag(mblk_t *, uint_t, uint16_t,
    link_tagmode_t);
static mblk_t   *i_dld_ether_header_strip_tag(mblk_t *, boolean_t);

static uint32_t         str_count;
static kmem_cache_t     *str_cachep;
static mod_hash_t       *str_hashp;

#define STR_HASHSZ              64
#define STR_HASH_KEY(key)       ((mod_hash_key_t)(uintptr_t)(key))

#define dld_taskq       system_taskq

static kmutex_t         dld_taskq_lock;
static kcondvar_t       dld_taskq_cv;
static list_t           dld_taskq_list;         /* List of dld_str_t */
boolean_t               dld_taskq_quit;
boolean_t               dld_taskq_done;

static void             dld_taskq_dispatch(void);

/*
 * Some notes on entry points, flow-control, queueing.
 *
 * This driver exports the traditional STREAMS put entry point as well as
 * the non-STREAMS fast-path transmit routine which is provided to IP via
 * the DL_CAPAB_POLL negotiation.  The put procedure handles all control
 * and data operations, while the fast-path routine deals only with M_DATA
 * fast-path packets.  Regardless of the entry point, all outbound packets
 * will end up in DLD_TX(), where they will be delivered to the MAC layer.
 *
 * The transmit logic operates in the following way: All packets coming
 * into DLD will be sent to the MAC layer through DLD_TX(). Flow-control
 * happens when the MAC layer indicates the packets couldn't be
 * transmitted due to 1) lack of resources (e.g. running out of
 * descriptors),  or 2) reaching the allowed bandwidth limit for this
 * particular flow. The indication comes in the form of a Tx cookie that
 * identifies the blocked ring. In such case, DLD will place a
 * dummy message on its write-side STREAMS queue so that the queue is
 * marked as "full". Any subsequent packets arriving at the driver will
 * still be sent to the MAC layer where it either gets queued in the Tx
 * SRS or discarded it if queue limit is exceeded. The write-side STREAMS
 * queue gets enabled when MAC layer notifies DLD through MAC_NOTE_TX.
 * When the write service procedure runs, it will remove the dummy
 * message from the write-side STREAMS queue; in effect this will trigger
 * backenabling. The sizes of q_hiwat and q_lowat are set to 1 and 0,
 * respectively, due to the above reasons.
 *
 * All non-data operations, both DLPI and ioctls are single threaded on a per
 * dld_str_t endpoint. This is done using a taskq so that the control operation
 * has kernel context and can cv_wait for resources. In addition all set type
 * operations that involve mac level state modification are serialized on a
 * per mac end point using the perimeter mechanism provided by the mac layer.
 * This serializes all mac clients trying to modify a single mac end point over
 * the entire sequence of mac calls made by that client as an atomic unit. The
 * mac framework locking is described in mac.c. A critical element is that
 * DLD/DLS does not hold any locks across the mac perimeter.
 *
 * dld_finddevinfo() returns the dev_info_t * corresponding to a particular
 * dev_t. It searches str_hashp (a table of dld_str_t's) for streams that
 * match dev_t. If a stream is found and it is attached, its dev_info_t *
 * is returned. If the mac handle is non-null, it can be safely accessed
 * below. The mac handle won't be freed until the mac_unregister which
 * won't happen until the driver detaches. The DDI framework ensures that
 * the detach won't happen while a getinfo is in progress.
 */
typedef struct i_dld_str_state_s {
        major_t         ds_major;
        minor_t         ds_minor;
        int             ds_instance;
        dev_info_t      *ds_dip;
} i_dld_str_state_t;

/* ARGSUSED */
static uint_t
i_dld_str_walker(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
{
        i_dld_str_state_t       *statep = arg;
        dld_str_t               *dsp = (dld_str_t *)val;
        mac_handle_t            mh;

        if (statep->ds_major != dsp->ds_major)
                return (MH_WALK_CONTINUE);

        ASSERT(statep->ds_minor != 0);
        mh = dsp->ds_mh;

        if (statep->ds_minor == dsp->ds_minor) {
                /*
                 * Clone: a clone minor is unique. we can terminate the
                 * walk if we find a matching stream -- even if we fail
                 * to obtain the devinfo.
                 */
                if (mh != NULL) {
                        statep->ds_dip = mac_devinfo_get(mh);
                        statep->ds_instance = DLS_MINOR2INST(mac_minor(mh));
                }
                return (MH_WALK_TERMINATE);
        }
        return (MH_WALK_CONTINUE);
}

static dev_info_t *
dld_finddevinfo(dev_t dev)
{
        dev_info_t              *dip;
        i_dld_str_state_t       state;

        if (getminor(dev) == 0)
                return (NULL);

        /*
         * See if it's a minor node of a link
         */
        if ((dip = dls_link_devinfo(dev)) != NULL)
                return (dip);

        state.ds_minor = getminor(dev);
        state.ds_major = getmajor(dev);
        state.ds_dip = NULL;
        state.ds_instance = -1;

        mod_hash_walk(str_hashp, i_dld_str_walker, &state);
        return (state.ds_dip);
}

int
dld_devt_to_instance(dev_t dev)
{
        minor_t                 minor;
        i_dld_str_state_t       state;

        /*
         * GLDv3 numbers DLPI style 1 node as the instance number + 1.
         * Minor number 0 is reserved for the DLPI style 2 unattached
         * node.
         */

        if ((minor = getminor(dev)) == 0)
                return (-1);

        /*
         * Check for unopened style 1 node.
         * Note that this doesn't *necessarily* work for legacy
         * devices, but this code is only called within the
         * getinfo(9e) implementation for true GLDv3 devices, so it
         * doesn't matter.
         */
        if (minor > 0 && minor <= DLS_MAX_MINOR) {
                return (DLS_MINOR2INST(minor));
        }

        state.ds_minor = getminor(dev);
        state.ds_major = getmajor(dev);
        state.ds_dip = NULL;
        state.ds_instance = -1;

        mod_hash_walk(str_hashp, i_dld_str_walker, &state);
        return (state.ds_instance);
}

/*
 * devo_getinfo: getinfo(9e)
 *
 * NB: This may be called for a provider before the provider's
 * instances are attached.  Hence, if a particular provider needs a
 * special mapping (the mac instance != ddi_get_instance()), then it
 * may need to provide its own implementation using the
 * mac_devt_to_instance() function, and translating the returned mac
 * instance to a devinfo instance.  For dev_t's where the minor number
 * is too large (i.e. > MAC_MAX_MINOR), the provider can call this
 * function indirectly via the mac_getinfo() function.
 */
/*ARGSUSED*/
int
dld_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resp)
{
        dev_info_t      *devinfo;
        minor_t         minor = getminor((dev_t)arg);
        int             rc = DDI_FAILURE;

        switch (cmd) {
        case DDI_INFO_DEVT2DEVINFO:
                if ((devinfo = dld_finddevinfo((dev_t)arg)) != NULL) {
                        *(dev_info_t **)resp = devinfo;
                        rc = DDI_SUCCESS;
                }
                break;
        case DDI_INFO_DEVT2INSTANCE:
                if (minor > 0 && minor <= DLS_MAX_MINOR) {
                        *resp = (void *)(uintptr_t)DLS_MINOR2INST(minor);
                        rc = DDI_SUCCESS;
                } else if (minor > DLS_MAX_MINOR &&
                    (devinfo = dld_finddevinfo((dev_t)arg)) != NULL) {
                        *resp = (void *)(uintptr_t)ddi_get_instance(devinfo);
                        rc = DDI_SUCCESS;
                }
                break;
        }
        return (rc);
}

void *
dld_str_private(queue_t *q)
{
        return (((dld_str_t *)(q->q_ptr))->ds_private);
}

int
dld_str_open(queue_t *rq, dev_t *devp, void *private)
{
        dld_str_t       *dsp;
        major_t         major;
        minor_t         minor;
        int             err;

        major = getmajor(*devp);
        minor = getminor(*devp);

        /*
         * Half the 32-bit minor space is reserved for private use by the driver
         * so we bail out here with `ENOSTR` to indicate specfs should retry the
         * open with the driver's character based `open(9E)`. For a typical
         * STREAMS driver, that would just be `nodev` which would simply return
         * `ENODEV`. But a dual-personality device can choose to implement the
         * character based `open(9E)` for some minor nodes. A driver wanting a
         * separate STREAMS interface altogether would presumably have already
         * provided its own `streamtab`.
         */
        if (minor >= mac_private_minor())
                return (ENOSTR);

        /*
         * Create a new dld_str_t for the stream. This will grab a new minor
         * number that will be handed back in the cloned dev_t.  Creation may
         * fail if we can't allocate the dummy mblk used for flow-control.
         */
        dsp = dld_str_create(rq, DLD_DLPI, major,
            ((minor == 0) ? DL_STYLE2 : DL_STYLE1));
        if (dsp == NULL)
                return (ENOSR);

        ASSERT(dsp->ds_dlstate == DL_UNATTACHED);
        dsp->ds_private = private;
        if (minor != 0) {
                /*
                 * Style 1 open
                 */
                if ((err = dld_str_attach(dsp, (t_uscalar_t)minor - 1)) != 0)
                        goto failed;

                ASSERT(dsp->ds_dlstate == DL_UNBOUND);
        } else {
                (void) qassociate(rq, -1);
        }

        /*
         * Enable the queue srv(9e) routine.
         */
        qprocson(rq);

        /*
         * Construct a cloned dev_t to hand back.
         */
        *devp = makedevice(getmajor(*devp), dsp->ds_minor);
        return (0);

failed:
        dld_str_destroy(dsp);
        return (err);
}

int
dld_str_close(queue_t *rq)
{
        dld_str_t       *dsp = rq->q_ptr;

        /*
         * All modules on top have been popped off. So there can't be any
         * threads from the top.
         */
        ASSERT(dsp->ds_datathr_cnt == 0);

        /*
         * Wait until pending DLPI requests are processed.
         */
        mutex_enter(&dsp->ds_lock);
        while (dsp->ds_dlpi_pending)
                cv_wait(&dsp->ds_dlpi_pending_cv, &dsp->ds_lock);
        mutex_exit(&dsp->ds_lock);


        /*
         * This stream was open to a provider node. Check to see
         * if it has been cleanly shut down.
         */
        if (dsp->ds_dlstate != DL_UNATTACHED) {
                /*
                 * The stream is either open to a style 1 provider or
                 * this is not clean shutdown. Detach from the PPA.
                 * (This is still ok even in the style 1 case).
                 */
                dld_str_detach(dsp);
        }

        dld_str_destroy(dsp);
        return (0);
}

/*
 * qi_qopen: open(9e)
 */
/*ARGSUSED*/
int
dld_open(queue_t *rq, dev_t *devp, int flag, int sflag, cred_t *credp)
{
        if (sflag == MODOPEN)
                return (ENOTSUP);

        /*
         * This is a cloning driver and therefore each queue should only
         * ever get opened once.
         */
        if (rq->q_ptr != NULL)
                return (EBUSY);

        return (dld_str_open(rq, devp, NULL));
}

/*
 * qi_qclose: close(9e)
 */
/* ARGSUSED */
int
dld_close(queue_t *rq, int flags __unused, cred_t *credp __unused)
{
        /*
         * Disable the queue srv(9e) routine.
         */
        qprocsoff(rq);

        return (dld_str_close(rq));
}

/*
 * qi_qputp: put(9e)
 */
int
dld_wput(queue_t *wq, mblk_t *mp)
{
        dld_str_t *dsp = (dld_str_t *)wq->q_ptr;
        dld_str_mode_t  mode;

        switch (DB_TYPE(mp)) {
        case M_DATA:
                mutex_enter(&dsp->ds_lock);
                mode = dsp->ds_mode;
                if ((dsp->ds_dlstate != DL_IDLE) ||
                    (mode != DLD_FASTPATH && mode != DLD_RAW)) {
                        mutex_exit(&dsp->ds_lock);
                        freemsg(mp);
                        break;
                }

                DLD_DATATHR_INC(dsp);
                mutex_exit(&dsp->ds_lock);
                if (mode == DLD_FASTPATH) {
                        if (dsp->ds_mip->mi_media == DL_ETHER &&
                            (MBLKL(mp) < sizeof (struct ether_header))) {
                                freemsg(mp);
                        } else {
                                (void) str_mdata_fastpath_put(dsp, mp, 0, 0);
                        }
                } else {
                        str_mdata_raw_put(dsp, mp);
                }
                DLD_DATATHR_DCR(dsp);
                break;
        case M_PROTO:
        case M_PCPROTO: {
                t_uscalar_t     prim;

                if (MBLKL(mp) < sizeof (t_uscalar_t))
                        break;

                prim = ((union DL_primitives *)mp->b_rptr)->dl_primitive;

                if (prim == DL_UNITDATA_REQ) {
                        proto_unitdata_req(dsp, mp);
                } else {
                        dld_wput_nondata(dsp, mp);
                }
                break;
        }

        case M_IOCTL:
                dld_wput_nondata(dsp, mp);
                break;

        case M_FLUSH:
                if (*mp->b_rptr & FLUSHW) {
                        DLD_CLRQFULL(dsp);
                        *mp->b_rptr &= ~FLUSHW;
                }

                if (*mp->b_rptr & FLUSHR) {
                        qreply(wq, mp);
                } else {
                        freemsg(mp);
                }
                break;

        default:
                freemsg(mp);
                break;
        }
        return (0);
}

/*
 * qi_srvp: srv(9e)
 */
int
dld_wsrv(queue_t *wq)
{
        dld_str_t       *dsp = wq->q_ptr;

        DLD_CLRQFULL(dsp);
        return (0);
}

void
dld_init_ops(struct dev_ops *ops, const char *name)
{
        struct streamtab *stream;
        struct qinit *rq, *wq;
        struct module_info *modinfo;

        modinfo = kmem_zalloc(sizeof (struct module_info), KM_SLEEP);
        modinfo->mi_idname = kmem_zalloc(FMNAMESZ, KM_SLEEP);
        (void) snprintf(modinfo->mi_idname, FMNAMESZ, "%s", name);
        modinfo->mi_minpsz = 0;
        modinfo->mi_maxpsz = 64*1024;
        modinfo->mi_hiwat  = 1;
        modinfo->mi_lowat = 0;

        rq = kmem_zalloc(sizeof (struct qinit), KM_SLEEP);
        rq->qi_qopen = dld_open;
        rq->qi_qclose = dld_close;
        rq->qi_minfo = modinfo;

        wq = kmem_zalloc(sizeof (struct qinit), KM_SLEEP);
        wq->qi_putp = (pfi_t)dld_wput;
        wq->qi_srvp = (pfi_t)dld_wsrv;
        wq->qi_minfo = modinfo;

        stream = kmem_zalloc(sizeof (struct streamtab), KM_SLEEP);
        stream->st_rdinit = rq;
        stream->st_wrinit = wq;
        ops->devo_cb_ops->cb_str = stream;

        if (ops->devo_getinfo == NULL)
                ops->devo_getinfo = &dld_getinfo;
}

void
dld_fini_ops(struct dev_ops *ops)
{
        struct streamtab *stream;
        struct qinit *rq, *wq;
        struct module_info *modinfo;

        stream = ops->devo_cb_ops->cb_str;
        rq = stream->st_rdinit;
        wq = stream->st_wrinit;
        modinfo = rq->qi_minfo;
        ASSERT(wq->qi_minfo == modinfo);

        kmem_free(stream, sizeof (struct streamtab));
        kmem_free(wq, sizeof (struct qinit));
        kmem_free(rq, sizeof (struct qinit));
        kmem_free(modinfo->mi_idname, FMNAMESZ);
        kmem_free(modinfo, sizeof (struct module_info));
}

/*
 * Initialize this module's data structures.
 */
void
dld_str_init(void)
{
        /*
         * Create dld_str_t object cache.
         */
        str_cachep = kmem_cache_create("dld_str_cache", sizeof (dld_str_t),
            0, str_constructor, str_destructor, NULL, NULL, NULL, 0);
        ASSERT(str_cachep != NULL);

        /*
         * Create a hash table for maintaining dld_str_t's.
         * The ds_minor field (the clone minor number) of a dld_str_t
         * is used as a key for this hash table because this number is
         * globally unique (allocated from "dls_minor_arena").
         */
        str_hashp = mod_hash_create_idhash("dld_str_hash", STR_HASHSZ,
            mod_hash_null_valdtor);

        mutex_init(&dld_taskq_lock, NULL, MUTEX_DRIVER, NULL);
        cv_init(&dld_taskq_cv, NULL, CV_DRIVER, NULL);

        dld_taskq_quit = B_FALSE;
        dld_taskq_done = B_FALSE;
        list_create(&dld_taskq_list, sizeof (dld_str_t),
            offsetof(dld_str_t, ds_tqlist));
        (void) thread_create(NULL, 0, dld_taskq_dispatch, NULL, 0,
            &p0, TS_RUN, minclsyspri);
}

/*
 * Tear down this module's data structures.
 */
int
dld_str_fini(void)
{
        /*
         * Make sure that there are no objects in use.
         */
        if (str_count != 0)
                return (EBUSY);

        /*
         * Ask the dld_taskq thread to quit and wait for it to be done
         */
        mutex_enter(&dld_taskq_lock);
        dld_taskq_quit = B_TRUE;
        cv_signal(&dld_taskq_cv);
        while (!dld_taskq_done)
                cv_wait(&dld_taskq_cv, &dld_taskq_lock);
        mutex_exit(&dld_taskq_lock);
        list_destroy(&dld_taskq_list);
        /*
         * Destroy object cache.
         */
        kmem_cache_destroy(str_cachep);
        mod_hash_destroy_idhash(str_hashp);
        return (0);
}

/*
 * Create a new dld_str_t object.
 */
dld_str_t *
dld_str_create(queue_t *rq, uint_t type, major_t major, t_uscalar_t style)
{
        dld_str_t       *dsp;
        int             err;

        /*
         * Allocate an object from the cache.
         */
        atomic_inc_32(&str_count);
        dsp = kmem_cache_alloc(str_cachep, KM_SLEEP);

        /*
         * Allocate the dummy mblk for flow-control.
         */
        dsp->ds_tx_flow_mp = allocb(1, BPRI_HI);
        if (dsp->ds_tx_flow_mp == NULL) {
                kmem_cache_free(str_cachep, dsp);
                atomic_dec_32(&str_count);
                return (NULL);
        }
        dsp->ds_type = type;
        dsp->ds_major = major;
        dsp->ds_style = style;

        /*
         * Initialize the queue pointers.
         */
        ASSERT(RD(rq) == rq);
        dsp->ds_rq = rq;
        dsp->ds_wq = WR(rq);
        rq->q_ptr = WR(rq)->q_ptr = (void *)dsp;

        /*
         * We want explicit control over our write-side STREAMS queue
         * where the dummy mblk gets added/removed for flow-control.
         */
        noenable(WR(rq));

        err = mod_hash_insert(str_hashp, STR_HASH_KEY(dsp->ds_minor),
            (mod_hash_val_t)dsp);
        ASSERT(err == 0);
        return (dsp);
}

/*
 * Destroy a dld_str_t object.
 */
void
dld_str_destroy(dld_str_t *dsp)
{
        queue_t         *rq;
        queue_t         *wq;
        mod_hash_val_t  val;

        /*
         * Clear the queue pointers.
         */
        rq = dsp->ds_rq;
        wq = dsp->ds_wq;
        ASSERT(wq == WR(rq));
        rq->q_ptr = wq->q_ptr = NULL;
        dsp->ds_rq = dsp->ds_wq = NULL;

        ASSERT(dsp->ds_dlstate == DL_UNATTACHED);
        ASSERT(dsp->ds_sap == 0);
        ASSERT(dsp->ds_mh == NULL);
        ASSERT(dsp->ds_mch == NULL);
        ASSERT(dsp->ds_promisc == 0);
        ASSERT(dsp->ds_mph == NULL);
        ASSERT(dsp->ds_mip == NULL);
        ASSERT(dsp->ds_mnh == NULL);

        ASSERT(dsp->ds_polling == B_FALSE);
        ASSERT(dsp->ds_direct == B_FALSE);
        ASSERT(dsp->ds_lso == B_FALSE);
        ASSERT(dsp->ds_lso_max == 0);
        ASSERT(dsp->ds_passivestate != DLD_ACTIVE);

        /*
         * Reinitialize all the flags.
         */
        dsp->ds_notifications = 0;
        dsp->ds_passivestate = DLD_UNINITIALIZED;
        dsp->ds_mode = DLD_UNITDATA;
        dsp->ds_native = B_FALSE;
        dsp->ds_nonip = B_FALSE;

        ASSERT(dsp->ds_datathr_cnt == 0);
        ASSERT(dsp->ds_pending_head == NULL);
        ASSERT(dsp->ds_pending_tail == NULL);
        ASSERT(!dsp->ds_dlpi_pending);

        ASSERT(dsp->ds_dlp == NULL);
        ASSERT(dsp->ds_dmap == NULL);
        ASSERT(dsp->ds_rx == NULL);
        ASSERT(dsp->ds_rx_arg == NULL);
        ASSERT(dsp->ds_next == NULL);
        ASSERT(dsp->ds_head == NULL);

        /*
         * Free the dummy mblk if exists.
         */
        if (dsp->ds_tx_flow_mp != NULL) {
                freeb(dsp->ds_tx_flow_mp);
                dsp->ds_tx_flow_mp = NULL;
        }

        (void) mod_hash_remove(str_hashp, STR_HASH_KEY(dsp->ds_minor), &val);
        ASSERT(dsp == (dld_str_t *)val);

        /*
         * Free the object back to the cache.
         */
        kmem_cache_free(str_cachep, dsp);
        atomic_dec_32(&str_count);
}

/*
 * kmem_cache contructor function: see kmem_cache_create(9f).
 */
/*ARGSUSED*/
static int
str_constructor(void *buf, void *cdrarg, int kmflags)
{
        dld_str_t       *dsp = buf;

        bzero(buf, sizeof (dld_str_t));

        /*
         * Allocate a new minor number.
         */
        if ((dsp->ds_minor = mac_minor_hold(kmflags == KM_SLEEP)) == 0)
                return (-1);

        /*
         * Initialize the DLPI state machine.
         */
        dsp->ds_dlstate = DL_UNATTACHED;

        mutex_init(&dsp->ds_lock, NULL, MUTEX_DRIVER, NULL);
        cv_init(&dsp->ds_datathr_cv, NULL, CV_DRIVER, NULL);
        cv_init(&dsp->ds_dlpi_pending_cv, NULL, CV_DRIVER, NULL);

        return (0);
}

/*
 * kmem_cache destructor function.
 */
/*ARGSUSED*/
static void
str_destructor(void *buf, void *cdrarg)
{
        dld_str_t       *dsp = buf;

        /*
         * Release the minor number.
         */
        mac_minor_rele(dsp->ds_minor);

        ASSERT(dsp->ds_tx_flow_mp == NULL);

        mutex_destroy(&dsp->ds_lock);
        cv_destroy(&dsp->ds_datathr_cv);
        cv_destroy(&dsp->ds_dlpi_pending_cv);
}

/*
 * Update the priority bits and VID (may need to insert tag if mp points
 * to an untagged packet.
 * If vid is VLAN_ID_NONE, use the VID encoded in the packet.
 */
static mblk_t *
i_dld_ether_header_update_tag(mblk_t *mp, uint_t pri, uint16_t vid,
    link_tagmode_t tagmode)
{
        mblk_t *hmp;
        struct ether_vlan_header *evhp;
        struct ether_header *ehp;
        uint16_t old_tci = 0;
        size_t len;

        ASSERT(pri != 0 || vid != VLAN_ID_NONE);

        evhp = (struct ether_vlan_header *)mp->b_rptr;
        if (ntohs(evhp->ether_tpid) == ETHERTYPE_VLAN) {
                /*
                 * Tagged packet, update the priority bits.
                 */
                len = sizeof (struct ether_vlan_header);

                if ((DB_REF(mp) > 1) || (MBLKL(mp) < len)) {
                        /*
                         * In case some drivers only check the db_ref
                         * count of the first mblk, we pullup the
                         * message into a single mblk.
                         */
                        hmp = msgpullup(mp, -1);
                        if ((hmp == NULL) || (MBLKL(hmp) < len)) {
                                freemsg(hmp);
                                return (NULL);
                        } else {
                                freemsg(mp);
                                mp = hmp;
                        }
                }

                evhp = (struct ether_vlan_header *)mp->b_rptr;
                old_tci = ntohs(evhp->ether_tci);
        } else {
                /*
                 * Untagged packet.  Two factors will cause us to insert a
                 * VLAN header:
                 * - This is a VLAN link (vid is specified)
                 * - The link supports user priority tagging and the priority
                 *   is non-zero.
                 */
                if (vid == VLAN_ID_NONE && tagmode == LINK_TAGMODE_VLANONLY)
                        return (mp);

                hmp = allocb(sizeof (struct ether_vlan_header), BPRI_MED);
                if (hmp == NULL)
                        return (NULL);

                evhp = (struct ether_vlan_header *)hmp->b_rptr;
                ehp = (struct ether_header *)mp->b_rptr;

                /*
                 * Copy the MAC addresses and typelen
                 */
                bcopy(ehp, evhp, (ETHERADDRL * 2));
                evhp->ether_type = ehp->ether_type;
                evhp->ether_tpid = htons(ETHERTYPE_VLAN);

                hmp->b_wptr += sizeof (struct ether_vlan_header);
                mp->b_rptr += sizeof (struct ether_header);

                /*
                 * Free the original message if it's now empty. Link the
                 * rest of the messages to the header message.
                 */
                if (MBLKL(mp) == 0) {
                        hmp->b_cont = mp->b_cont;
                        freeb(mp);
                } else {
                        hmp->b_cont = mp;
                }
                mp = hmp;
        }

        if (pri == 0)
                pri = VLAN_PRI(old_tci);
        if (vid == VLAN_ID_NONE)
                vid = VLAN_ID(old_tci);
        evhp->ether_tci = htons(VLAN_TCI(pri, VLAN_CFI(old_tci), vid));
        return (mp);
}

/*
 * M_DATA put (IP fast-path mode)
 */
mac_tx_cookie_t
str_mdata_fastpath_put(dld_str_t *dsp, mblk_t *mp, uintptr_t f_hint,
    uint16_t flag)
{
        boolean_t is_ethernet = (dsp->ds_mip->mi_media == DL_ETHER);
        mblk_t *newmp;
        uint_t pri;
        mac_tx_cookie_t cookie;

        if (is_ethernet) {
                /*
                 * Update the priority bits to the assigned priority.
                 */
                pri = (VLAN_MBLKPRI(mp) == 0) ? dsp->ds_pri : VLAN_MBLKPRI(mp);

                if (pri != 0) {
                        newmp = i_dld_ether_header_update_tag(mp, pri,
                            VLAN_ID_NONE, dsp->ds_dlp->dl_tagmode);
                        if (newmp == NULL)
                                goto discard;
                        mp = newmp;
                }
        }

        if ((cookie = DLD_TX(dsp, mp, f_hint, flag)) != 0) {
                DLD_SETQFULL(dsp);
        }
        return (cookie);

discard:
        /* TODO: bump kstat? */
        freemsg(mp);
        return (0);
}

/*
 * M_DATA put (DLIOCRAW mode)
 */
static void
str_mdata_raw_put(dld_str_t *dsp, mblk_t *mp)
{
        boolean_t is_ethernet = (dsp->ds_mip->mi_media == DL_ETHER);
        mblk_t *bp, *newmp;
        size_t size;
        mac_header_info_t mhi;
        uint_t pri, vid, dvid;
        uint_t max_sdu;

        /*
         * Certain MAC type plugins provide an illusion for raw DLPI
         * consumers.  They pretend that the MAC layer is something that
         * it's not for the benefit of observability tools.  For example,
         * mac_wifi pretends that it's Ethernet for such consumers.
         * Here, unless native mode is enabled, we call into the MAC layer so
         * that this illusion can be maintained.  The plugin will optionally
         * transform the MAC header here into something that can be passed
         * down.  The header goes from raw mode to "cooked" mode.
         */
        if (!dsp->ds_native) {
                if ((newmp = mac_header_cook(dsp->ds_mh, mp)) == NULL)
                        goto discard;
                mp = newmp;
        }

        size = MBLKL(mp);

        /*
         * Check the packet is not too big and that any remaining
         * fragment list is composed entirely of M_DATA messages. (We
         * know the first fragment was M_DATA otherwise we could not
         * have got here).
         */
        for (bp = mp->b_cont; bp != NULL; bp = bp->b_cont) {
                if (DB_TYPE(bp) != M_DATA)
                        goto discard;
                size += MBLKL(bp);
        }

        if (mac_vlan_header_info(dsp->ds_mh, mp, &mhi) != 0)
                goto discard;

        mac_sdu_get(dsp->ds_mh, NULL, &max_sdu);
        /*
         * If LSO is enabled, check the size against lso_max. Otherwise,
         * compare the packet size with max_sdu.
         */
        max_sdu = dsp->ds_lso ? dsp->ds_lso_max : max_sdu;
        if (size > max_sdu + mhi.mhi_hdrsize)
                goto discard;

        if (is_ethernet) {
                dvid = mac_client_vid(dsp->ds_mch);

                /*
                 * Discard the packet if this is a VLAN stream but the VID in
                 * the packet is not correct.
                 */
                vid = VLAN_ID(mhi.mhi_tci);
                if ((dvid != VLAN_ID_NONE) && (vid != VLAN_ID_NONE))
                        goto discard;

                /*
                 * Discard the packet if this packet is a tagged packet
                 * but both pri and VID are 0.
                 */
                pri = VLAN_PRI(mhi.mhi_tci);
                if (mhi.mhi_istagged && !mhi.mhi_ispvid && pri == 0 &&
                    vid == VLAN_ID_NONE)
                        goto discard;

                /*
                 * Update the priority bits to the per-stream priority if
                 * priority is not set in the packet. Update the VID for
                 * packets on a VLAN stream.
                 */
                pri = (pri == 0) ? dsp->ds_pri : 0;
                if ((pri != 0) || (dvid != VLAN_ID_NONE)) {
                        if ((newmp = i_dld_ether_header_update_tag(mp, pri,
                            dvid, dsp->ds_dlp->dl_tagmode)) == NULL) {
                                goto discard;
                        }
                        mp = newmp;
                }
        }

        if (DLD_TX(dsp, mp, 0, 0) != 0) {
                /* Turn on flow-control for dld */
                DLD_SETQFULL(dsp);
        }
        return;

discard:
        /* TODO: bump kstat? */
        freemsg(mp);
}

/*
 * Process DL_ATTACH_REQ (style 2) or open(2) (style 1).
 */
int
dld_str_attach(dld_str_t *dsp, t_uscalar_t ppa)
{
        dev_t                   dev;
        int                     err;
        const char              *drvname;
        mac_perim_handle_t      mph = NULL;
        boolean_t               qassociated = B_FALSE;
        dls_link_t              *dlp = NULL;
        dls_dl_handle_t         ddp = NULL;

        if ((drvname = ddi_major_to_name(dsp->ds_major)) == NULL)
                return (EINVAL);

        if (dsp->ds_style == DL_STYLE2 && ppa > DLS_MAX_PPA)
                return (ENOTSUP);

        /*
         * /dev node access. This will still be supported for backward
         * compatibility reason.
         */
        if ((dsp->ds_style == DL_STYLE2) && (strcmp(drvname, "aggr") != 0) &&
            (strcmp(drvname, "vnic") != 0)) {
                if (qassociate(dsp->ds_wq, DLS_PPA2INST(ppa)) != 0)
                        return (EINVAL);
                qassociated = B_TRUE;
        }

        dev = makedevice(dsp->ds_major, (minor_t)ppa + 1);
        if ((err = dls_devnet_hold_by_dev(dev, &ddp)) != 0)
                goto failed;

        if ((err = mac_perim_enter_by_macname(dls_devnet_mac(ddp), &mph)) != 0)
                goto failed;

        /*
         * Open a channel.
         */
        if ((err = dls_link_hold(dls_devnet_mac(ddp), &dlp)) != 0)
                goto failed;

        if ((err = dls_open(dlp, ddp, dsp)) != 0)
                goto failed;

        /*
         * Set the default packet priority.
         */
        dsp->ds_pri = 0;

        /*
         * Add a notify function so that the we get updates from the MAC.
         */
        dsp->ds_mnh = mac_notify_add(dsp->ds_mh, str_notify, dsp);
        dsp->ds_dlstate = DL_UNBOUND;
        mac_perim_exit(mph);
        return (0);

failed:
        if (dlp != NULL)
                dls_link_rele(dlp);
        if (mph != NULL)
                mac_perim_exit(mph);
        if (ddp != NULL)
                dls_devnet_rele(ddp);
        if (qassociated)
                (void) qassociate(dsp->ds_wq, -1);

        return (err);
}

/*
 * Process DL_DETACH_REQ (style 2) or close(2) (style 1). Can also be called
 * from close(2) for style 2.
 */
void
dld_str_detach(dld_str_t *dsp)
{
        mac_perim_handle_t      mph;
        int                     err;

        ASSERT(dsp->ds_datathr_cnt == 0);

        mac_perim_enter_by_mh(dsp->ds_mh, &mph);
        /*
         * Remove the notify function.
         *
         * Note that we cannot wait for the notification callback to be removed
         * since it could cause the deadlock with str_notify() since they both
         * need the mac perimeter. Continue if we cannot remove the
         * notification callback right now and wait after we leave the
         * perimeter.
         */
        err = mac_notify_remove(dsp->ds_mnh, B_FALSE);
        dsp->ds_mnh = NULL;

        /*
         * Disable the capabilities
         */
        dld_capabilities_disable(dsp);

        /*
         * Clear LSO flags.
         */
        dsp->ds_lso = B_FALSE;
        dsp->ds_lso_max = 0;

        dls_close(dsp);
        mac_perim_exit(mph);

        /*
         * Now we leave the mac perimeter. If mac_notify_remove() failed
         * because the notification callback was in progress, wait for
         * it to finish before we proceed.
         */
        if (err != 0)
                mac_notify_remove_wait(dsp->ds_mh);

        /*
         * An unreferenced tagged (non-persistent) vlan gets destroyed
         * automatically in the call to dls_devnet_rele.
         */
        dls_devnet_rele(dsp->ds_ddh);

        dsp->ds_sap = 0;
        dsp->ds_mh = NULL;
        dsp->ds_mch = NULL;
        dsp->ds_mip = NULL;

        if (dsp->ds_style == DL_STYLE2)
                (void) qassociate(dsp->ds_wq, -1);

        /*
         * Re-initialize the DLPI state machine.
         */
        dsp->ds_dlstate = DL_UNATTACHED;
}

/*
 * This function is only called for VLAN streams. In raw mode, we strip VLAN
 * tags before sending packets up to the DLS clients, with the exception of
 * special priority tagged packets, in that case, we set the VID to 0.
 * mp must be a VLAN tagged packet.
 */
static mblk_t *
i_dld_ether_header_strip_tag(mblk_t *mp, boolean_t keep_pri)
{
        mblk_t *newmp;
        struct ether_vlan_header *evhp;
        uint16_t tci, new_tci;

        ASSERT(MBLKL(mp) >= sizeof (struct ether_vlan_header));
        if (DB_REF(mp) > 1) {
                newmp = copymsg(mp);
                if (newmp == NULL)
                        return (NULL);
                freemsg(mp);
                mp = newmp;
        }
        evhp = (struct ether_vlan_header *)mp->b_rptr;

        tci = ntohs(evhp->ether_tci);
        if (VLAN_PRI(tci) == 0 || !keep_pri) {
                /*
                 * Priority is 0, strip the tag.
                 */
                ovbcopy(mp->b_rptr, mp->b_rptr + VLAN_TAGSZ, 2 * ETHERADDRL);
                mp->b_rptr += VLAN_TAGSZ;
        } else {
                /*
                 * Priority is not 0, update the VID to 0.
                 */
                new_tci = VLAN_TCI(VLAN_PRI(tci), VLAN_CFI(tci), VLAN_ID_NONE);
                evhp->ether_tci = htons(new_tci);
        }
        return (mp);
}

/*
 * Raw mode receive function.
 */
/*ARGSUSED*/
void
dld_str_rx_raw(void *arg, mac_resource_handle_t mrh, mblk_t *mp,
    mac_header_info_t *mhip)
{
        dld_str_t *dsp = (dld_str_t *)arg;
        boolean_t is_ethernet = (dsp->ds_mip->mi_media == DL_ETHER);
        mblk_t *next, *newmp;

        ASSERT(mp != NULL);
        do {
                /*
                 * Get the pointer to the next packet in the chain and then
                 * clear b_next before the packet gets passed on.
                 */
                next = mp->b_next;
                mp->b_next = NULL;

                /*
                 * Wind back b_rptr to point at the MAC header.
                 */
                ASSERT(mp->b_rptr >= DB_BASE(mp) + mhip->mhi_hdrsize);
                mp->b_rptr -= mhip->mhi_hdrsize;

                /*
                 * Certain MAC type plugins provide an illusion for raw
                 * DLPI consumers.  They pretend that the MAC layer is
                 * something that it's not for the benefit of observability
                 * tools.  For example, mac_wifi pretends that it's Ethernet
                 * for such consumers.  Here, unless native mode is enabled,
                 * we call into the MAC layer so that this illusion can be
                 * maintained.  The plugin will optionally transform the MAC
                 * header here into something that can be passed up to raw
                 * consumers.  The header goes from "cooked" mode to raw mode.
                 */
                if (!dsp->ds_native) {
                        newmp = mac_header_uncook(dsp->ds_mh, mp);
                        if (newmp == NULL) {
                                freemsg(mp);
                                goto next;
                        }
                        mp = newmp;
                }

                /*
                 * Strip the VLAN tag for VLAN streams.
                 */
                if (is_ethernet &&
                    mac_client_vid(dsp->ds_mch) != VLAN_ID_NONE) {
                        /*
                         * The priority should be kept only for VLAN
                         * data-links.
                         */
                        newmp = i_dld_ether_header_strip_tag(mp,
                            mac_client_is_vlan_vnic(dsp->ds_mch));
                        if (newmp == NULL) {
                                freemsg(mp);
                                goto next;
                        }
                        mp = newmp;
                }

                /*
                 * Pass the packet on.
                 */
                if (canputnext(dsp->ds_rq))
                        putnext(dsp->ds_rq, mp);
                else
                        freemsg(mp);

next:
                /*
                 * Move on to the next packet in the chain.
                 */
                mp = next;
        } while (mp != NULL);
}

/*
 * Fast-path receive function.
 */
/*ARGSUSED*/
void
dld_str_rx_fastpath(void *arg, mac_resource_handle_t mrh, mblk_t *mp,
    mac_header_info_t *mhip)
{
        dld_str_t *dsp = (dld_str_t *)arg;
        mblk_t *next;
        size_t offset = 0;

        /*
         * MAC header stripping rules:
         *    - Tagged packets:
         *      a. VLAN streams. Strip the whole VLAN header including the tag.
         *      b. Physical streams
         *      - VLAN packets (non-zero VID). The stream must be either a
         *        DL_PROMISC_SAP listener or a ETHERTYPE_VLAN listener.
         *        Strip the Ethernet header but keep the VLAN header.
         *      - Special tagged packets (zero VID)
         *        * The stream is either a DL_PROMISC_SAP listener or a
         *          ETHERTYPE_VLAN listener, strip the Ethernet header but
         *          keep the VLAN header.
         *        * Otherwise, strip the whole VLAN header.
         *    - Untagged packets. Strip the whole MAC header.
         */
        if (mhip->mhi_istagged &&
            (mac_client_vid(dsp->ds_mch) == VLAN_ID_NONE) &&
            ((dsp->ds_sap == ETHERTYPE_VLAN) ||
            (dsp->ds_promisc & DLS_PROMISC_SAP))) {
                offset = VLAN_TAGSZ;
        }

        ASSERT(mp != NULL);
        do {
                /*
                 * Get the pointer to the next packet in the chain and then
                 * clear b_next before the packet gets passed on.
                 */
                next = mp->b_next;
                mp->b_next = NULL;

                /*
                 * Wind back b_rptr to point at the VLAN header.
                 */
                ASSERT(mp->b_rptr >= DB_BASE(mp) + offset);
                mp->b_rptr -= offset;

                /*
                 * Pass the packet on.
                 */
                if (canputnext(dsp->ds_rq))
                        putnext(dsp->ds_rq, mp);
                else
                        freemsg(mp);
                /*
                 * Move on to the next packet in the chain.
                 */
                mp = next;
        } while (mp != NULL);
}

/*
 * Default receive function (send DL_UNITDATA_IND messages).
 */
/*ARGSUSED*/
void
dld_str_rx_unitdata(void *arg, mac_resource_handle_t mrh, mblk_t *mp,
    mac_header_info_t *mhip)
{
        dld_str_t               *dsp = (dld_str_t *)arg;
        mblk_t                  *ud_mp;
        mblk_t                  *next;
        size_t                  offset = 0;
        boolean_t               strip_vlan = B_TRUE;

        /*
         * See MAC header stripping rules in the dld_str_rx_fastpath() function.
         */
        if (mhip->mhi_istagged &&
            (mac_client_vid(dsp->ds_mch) == VLAN_ID_NONE) &&
            ((dsp->ds_sap == ETHERTYPE_VLAN) ||
            (dsp->ds_promisc & DLS_PROMISC_SAP))) {
                offset = VLAN_TAGSZ;
                strip_vlan = B_FALSE;
        }

        ASSERT(mp != NULL);
        do {
                /*
                 * Get the pointer to the next packet in the chain and then
                 * clear b_next before the packet gets passed on.
                 */
                next = mp->b_next;
                mp->b_next = NULL;

                /*
                 * Wind back b_rptr to point at the MAC header.
                 */
                ASSERT(mp->b_rptr >= DB_BASE(mp) + mhip->mhi_hdrsize);
                mp->b_rptr -= mhip->mhi_hdrsize;

                /*
                 * Create the DL_UNITDATA_IND M_PROTO.
                 */
                if ((ud_mp = str_unitdata_ind(dsp, mp, strip_vlan)) == NULL) {
                        freemsgchain(mp);
                        return;
                }

                /*
                 * Advance b_rptr to point at the payload (or the VLAN header).
                 */
                mp->b_rptr += (mhip->mhi_hdrsize - offset);

                /*
                 * Prepend the DL_UNITDATA_IND.
                 */
                ud_mp->b_cont = mp;

                /*
                 * Send the message.
                 */
                if (canputnext(dsp->ds_rq))
                        putnext(dsp->ds_rq, ud_mp);
                else
                        freemsg(ud_mp);

                /*
                 * Move on to the next packet in the chain.
                 */
                mp = next;
        } while (mp != NULL);
}

/*
 * DL_NOTIFY_IND: DL_NOTE_SDU_SIZE
 */
static void
str_notify_sdu_size(dld_str_t *dsp, uint_t max_sdu, uint_t multicast_sdu)
{
        mblk_t          *mp;
        dl_notify_ind_t *dlip;

        if (!(dsp->ds_notifications & (DL_NOTE_SDU_SIZE|DL_NOTE_SDU_SIZE2)))
                return;

        if ((mp = mexchange(dsp->ds_wq, NULL, sizeof (dl_notify_ind_t),
            M_PROTO, 0)) == NULL)
                return;

        bzero(mp->b_rptr, sizeof (dl_notify_ind_t));
        dlip = (dl_notify_ind_t *)mp->b_rptr;
        dlip->dl_primitive = DL_NOTIFY_IND;
        if (dsp->ds_notifications & DL_NOTE_SDU_SIZE2) {
                dlip->dl_notification = DL_NOTE_SDU_SIZE2;
                dlip->dl_data1 = max_sdu;
                dlip->dl_data2 = multicast_sdu;
        } else {
                dlip->dl_notification = DL_NOTE_SDU_SIZE;
                dlip->dl_data = max_sdu;
        }

        qreply(dsp->ds_wq, mp);
}

/*
 * Generate DL_NOTIFY_IND messages to notify the DLPI consumer of the
 * current state of the interface.
 */
void
dld_str_notify_ind(dld_str_t *dsp)
{
        mac_notify_type_t       type;

        for (type = 0; type < MAC_NNOTE; type++)
                str_notify(dsp, type);
}

typedef struct dl_unitdata_ind_wrapper {
        dl_unitdata_ind_t       dl_unitdata;
        uint8_t                 dl_dest_addr[MAXMACADDRLEN + sizeof (uint16_t)];
        uint8_t                 dl_src_addr[MAXMACADDRLEN + sizeof (uint16_t)];
} dl_unitdata_ind_wrapper_t;

/*
 * Create a DL_UNITDATA_IND M_PROTO message.
 */
static mblk_t *
str_unitdata_ind(dld_str_t *dsp, mblk_t *mp, boolean_t strip_vlan)
{
        mblk_t                          *nmp;
        dl_unitdata_ind_wrapper_t       *dlwp;
        dl_unitdata_ind_t               *dlp;
        mac_header_info_t               mhi;
        uint_t                          addr_length;
        uint8_t                         *daddr;
        uint8_t                         *saddr;

        /*
         * Get the packet header information.
         */
        if (mac_vlan_header_info(dsp->ds_mh, mp, &mhi) != 0)
                return (NULL);

        /*
         * Allocate a message large enough to contain the wrapper structure
         * defined above.
         */
        if ((nmp = mexchange(dsp->ds_wq, NULL,
            sizeof (dl_unitdata_ind_wrapper_t), M_PROTO,
            DL_UNITDATA_IND)) == NULL)
                return (NULL);

        dlwp = (dl_unitdata_ind_wrapper_t *)nmp->b_rptr;

        dlp = &(dlwp->dl_unitdata);
        ASSERT(dlp == (dl_unitdata_ind_t *)nmp->b_rptr);
        ASSERT(dlp->dl_primitive == DL_UNITDATA_IND);

        /*
         * Copy in the destination address.
         */
        addr_length = dsp->ds_mip->mi_addr_length;
        daddr = dlwp->dl_dest_addr;
        dlp->dl_dest_addr_offset = (uintptr_t)daddr - (uintptr_t)dlp;
        bcopy(mhi.mhi_daddr, daddr, addr_length);

        /*
         * Set the destination DLSAP to the SAP value encoded in the packet.
         */
        if (mhi.mhi_istagged && !strip_vlan)
                *(uint16_t *)(daddr + addr_length) = ETHERTYPE_VLAN;
        else
                *(uint16_t *)(daddr + addr_length) = mhi.mhi_bindsap;
        dlp->dl_dest_addr_length = addr_length + sizeof (uint16_t);

        /*
         * If the destination address was multicast or broadcast then the
         * dl_group_address field should be non-zero.
         */
        dlp->dl_group_address = (mhi.mhi_dsttype == MAC_ADDRTYPE_MULTICAST) ||
            (mhi.mhi_dsttype == MAC_ADDRTYPE_BROADCAST);

        /*
         * Copy in the source address if one exists.  Some MAC types (DL_IB
         * for example) may not have access to source information.
         */
        if (mhi.mhi_saddr == NULL) {
                dlp->dl_src_addr_offset = dlp->dl_src_addr_length = 0;
        } else {
                saddr = dlwp->dl_src_addr;
                dlp->dl_src_addr_offset = (uintptr_t)saddr - (uintptr_t)dlp;
                bcopy(mhi.mhi_saddr, saddr, addr_length);

                /*
                 * Set the source DLSAP to the packet ethertype.
                 */
                *(uint16_t *)(saddr + addr_length) = mhi.mhi_origsap;
                dlp->dl_src_addr_length = addr_length + sizeof (uint16_t);
        }

        return (nmp);
}

/*
 * DL_NOTIFY_IND: DL_NOTE_PROMISC_ON_PHYS
 */
static void
str_notify_promisc_on_phys(dld_str_t *dsp)
{
        mblk_t          *mp;
        dl_notify_ind_t *dlip;

        if (!(dsp->ds_notifications & DL_NOTE_PROMISC_ON_PHYS))
                return;

        if ((mp = mexchange(dsp->ds_wq, NULL, sizeof (dl_notify_ind_t),
            M_PROTO, 0)) == NULL)
                return;

        bzero(mp->b_rptr, sizeof (dl_notify_ind_t));
        dlip = (dl_notify_ind_t *)mp->b_rptr;
        dlip->dl_primitive = DL_NOTIFY_IND;
        dlip->dl_notification = DL_NOTE_PROMISC_ON_PHYS;

        qreply(dsp->ds_wq, mp);
}

/*
 * DL_NOTIFY_IND: DL_NOTE_PROMISC_OFF_PHYS
 */
static void
str_notify_promisc_off_phys(dld_str_t *dsp)
{
        mblk_t          *mp;
        dl_notify_ind_t *dlip;

        if (!(dsp->ds_notifications & DL_NOTE_PROMISC_OFF_PHYS))
                return;

        if ((mp = mexchange(dsp->ds_wq, NULL, sizeof (dl_notify_ind_t),
            M_PROTO, 0)) == NULL)
                return;

        bzero(mp->b_rptr, sizeof (dl_notify_ind_t));
        dlip = (dl_notify_ind_t *)mp->b_rptr;
        dlip->dl_primitive = DL_NOTIFY_IND;
        dlip->dl_notification = DL_NOTE_PROMISC_OFF_PHYS;

        qreply(dsp->ds_wq, mp);
}

/*
 * DL_NOTIFY_IND: DL_NOTE_PHYS_ADDR
 */
static void
str_notify_phys_addr(dld_str_t *dsp, uint_t addr_type, const uint8_t *addr)
{
        mblk_t          *mp;
        dl_notify_ind_t *dlip;
        uint_t          addr_length;
        uint16_t        ethertype;

        if (!(dsp->ds_notifications & DL_NOTE_PHYS_ADDR))
                return;

        addr_length = dsp->ds_mip->mi_addr_length;
        if ((mp = mexchange(dsp->ds_wq, NULL,
            sizeof (dl_notify_ind_t) + addr_length + sizeof (uint16_t),
            M_PROTO, 0)) == NULL)
                return;

        bzero(mp->b_rptr, sizeof (dl_notify_ind_t));
        dlip = (dl_notify_ind_t *)mp->b_rptr;
        dlip->dl_primitive = DL_NOTIFY_IND;
        dlip->dl_notification = DL_NOTE_PHYS_ADDR;
        dlip->dl_data = addr_type;
        dlip->dl_addr_offset = sizeof (dl_notify_ind_t);
        dlip->dl_addr_length = addr_length + sizeof (uint16_t);

        bcopy(addr, &dlip[1], addr_length);

        ethertype = (dsp->ds_sap < ETHERTYPE_802_MIN) ? 0 : dsp->ds_sap;
        *(uint16_t *)((uchar_t *)(dlip + 1) + addr_length) = ethertype;

        qreply(dsp->ds_wq, mp);
}

/*
 * DL_NOTIFY_IND: DL_NOTE_LINK_UP
 */
static void
str_notify_link_up(dld_str_t *dsp)
{
        mblk_t          *mp;
        dl_notify_ind_t *dlip;

        if (!(dsp->ds_notifications & DL_NOTE_LINK_UP))
                return;

        if ((mp = mexchange(dsp->ds_wq, NULL, sizeof (dl_notify_ind_t),
            M_PROTO, 0)) == NULL)
                return;

        bzero(mp->b_rptr, sizeof (dl_notify_ind_t));
        dlip = (dl_notify_ind_t *)mp->b_rptr;
        dlip->dl_primitive = DL_NOTIFY_IND;
        dlip->dl_notification = DL_NOTE_LINK_UP;

        qreply(dsp->ds_wq, mp);
}

/*
 * DL_NOTIFY_IND: DL_NOTE_LINK_DOWN
 */
static void
str_notify_link_down(dld_str_t *dsp)
{
        mblk_t          *mp;
        dl_notify_ind_t *dlip;

        if (!(dsp->ds_notifications & DL_NOTE_LINK_DOWN))
                return;

        if ((mp = mexchange(dsp->ds_wq, NULL, sizeof (dl_notify_ind_t),
            M_PROTO, 0)) == NULL)
                return;

        bzero(mp->b_rptr, sizeof (dl_notify_ind_t));
        dlip = (dl_notify_ind_t *)mp->b_rptr;
        dlip->dl_primitive = DL_NOTIFY_IND;
        dlip->dl_notification = DL_NOTE_LINK_DOWN;

        qreply(dsp->ds_wq, mp);
}

/*
 * DL_NOTIFY_IND: DL_NOTE_SPEED
 */
static void
str_notify_speed(dld_str_t *dsp, uint32_t speed)
{
        mblk_t          *mp;
        dl_notify_ind_t *dlip;

        if (!(dsp->ds_notifications & DL_NOTE_SPEED))
                return;

        if ((mp = mexchange(dsp->ds_wq, NULL, sizeof (dl_notify_ind_t),
            M_PROTO, 0)) == NULL)
                return;

        bzero(mp->b_rptr, sizeof (dl_notify_ind_t));
        dlip = (dl_notify_ind_t *)mp->b_rptr;
        dlip->dl_primitive = DL_NOTIFY_IND;
        dlip->dl_notification = DL_NOTE_SPEED;
        dlip->dl_data = speed;

        qreply(dsp->ds_wq, mp);
}

/*
 * DL_NOTIFY_IND: DL_NOTE_CAPAB_RENEG
 */
static void
str_notify_capab_reneg(dld_str_t *dsp)
{
        mblk_t          *mp;
        dl_notify_ind_t *dlip;

        if (!(dsp->ds_notifications & DL_NOTE_CAPAB_RENEG))
                return;

        if ((mp = mexchange(dsp->ds_wq, NULL, sizeof (dl_notify_ind_t),
            M_PROTO, 0)) == NULL)
                return;

        bzero(mp->b_rptr, sizeof (dl_notify_ind_t));
        dlip = (dl_notify_ind_t *)mp->b_rptr;
        dlip->dl_primitive = DL_NOTIFY_IND;
        dlip->dl_notification = DL_NOTE_CAPAB_RENEG;

        qreply(dsp->ds_wq, mp);
}

/*
 * DL_NOTIFY_IND: DL_NOTE_FASTPATH_FLUSH
 */
static void
str_notify_fastpath_flush(dld_str_t *dsp)
{
        mblk_t          *mp;
        dl_notify_ind_t *dlip;

        if (!(dsp->ds_notifications & DL_NOTE_FASTPATH_FLUSH))
                return;

        if ((mp = mexchange(dsp->ds_wq, NULL, sizeof (dl_notify_ind_t),
            M_PROTO, 0)) == NULL)
                return;

        bzero(mp->b_rptr, sizeof (dl_notify_ind_t));
        dlip = (dl_notify_ind_t *)mp->b_rptr;
        dlip->dl_primitive = DL_NOTIFY_IND;
        dlip->dl_notification = DL_NOTE_FASTPATH_FLUSH;

        qreply(dsp->ds_wq, mp);
}

static void
str_notify_allowed_ips(dld_str_t *dsp)
{
        mblk_t          *mp;
        dl_notify_ind_t *dlip;
        size_t          mp_size;
        mac_protect_t   *mrp;

        if (!(dsp->ds_notifications & DL_NOTE_ALLOWED_IPS))
                return;

        mp_size = sizeof (mac_protect_t) + sizeof (dl_notify_ind_t);
        if ((mp = mexchange(dsp->ds_wq, NULL, mp_size, M_PROTO, 0)) == NULL)
                return;

        mrp = mac_protect_get(dsp->ds_mh);
        bzero(mp->b_rptr, mp_size);
        dlip = (dl_notify_ind_t *)mp->b_rptr;
        dlip->dl_primitive = DL_NOTIFY_IND;
        dlip->dl_notification = DL_NOTE_ALLOWED_IPS;
        dlip->dl_data = 0;
        dlip->dl_addr_offset = sizeof (dl_notify_ind_t);
        dlip->dl_addr_length = sizeof (mac_protect_t);
        bcopy(mrp, mp->b_rptr + sizeof (dl_notify_ind_t),
            sizeof (mac_protect_t));

        qreply(dsp->ds_wq, mp);
}

/*
 * MAC notification callback.
 */
void
str_notify(void *arg, mac_notify_type_t type)
{
        dld_str_t               *dsp = (dld_str_t *)arg;
        queue_t                 *q = dsp->ds_wq;
        mac_handle_t            mh = dsp->ds_mh;
        mac_client_handle_t     mch = dsp->ds_mch;
        uint8_t                 addr[MAXMACADDRLEN];

        switch (type) {
        case MAC_NOTE_TX:
                qenable(q);
                break;

        case MAC_NOTE_DEVPROMISC:
                /*
                 * Send the appropriate DL_NOTIFY_IND.
                 */
                if (mac_promisc_get(mh))
                        str_notify_promisc_on_phys(dsp);
                else
                        str_notify_promisc_off_phys(dsp);
                break;

        case MAC_NOTE_UNICST:
                /*
                 * This notification is sent whenever the MAC unicast
                 * address changes.
                 */
                mac_unicast_primary_get(mh, addr);

                /*
                 * Send the appropriate DL_NOTIFY_IND.
                 */
                str_notify_phys_addr(dsp, DL_CURR_PHYS_ADDR, addr);
                break;

        case MAC_NOTE_DEST:
                /*
                 * Only send up DL_NOTE_DEST_ADDR if the link has a
                 * destination address.
                 */
                if (mac_dst_get(dsp->ds_mh, addr))
                        str_notify_phys_addr(dsp, DL_CURR_DEST_ADDR, addr);
                break;

        case MAC_NOTE_LOWLINK:
        case MAC_NOTE_LINK:
                /*
                 * LOWLINK refers to the actual link status. For links that
                 * are not part of a bridge instance LOWLINK and LINK state
                 * are the same. But for a link part of a bridge instance
                 * LINK state refers to the aggregate link status: "up" when
                 * at least one link part of the bridge is up and is "down"
                 * when all links part of the bridge are down.
                 *
                 * Clients can request to be notified of the LOWLINK state
                 * using the DLIOCLOWLINK ioctl. Clients such as the bridge
                 * daemon request lowlink state changes and upper layer clients
                 * receive notifications of the aggregate link state changes
                 * which is the default when requesting LINK UP/DOWN state
                 * notifications.
                 */

                /*
                 * Check that the notification type matches the one that we
                 * want.  If we want lower-level link notifications, and this
                 * is upper, or if we want upper and this is lower, then
                 * ignore.
                 */
                if ((type == MAC_NOTE_LOWLINK) != dsp->ds_lowlink)
                        break;
                /*
                 * This notification is sent every time the MAC driver
                 * updates the link state.
                 */
                switch (mac_client_stat_get(mch, dsp->ds_lowlink ?
                    MAC_STAT_LOWLINK_STATE : MAC_STAT_LINK_STATE)) {
                case LINK_STATE_UP: {
                        uint64_t speed;
                        /*
                         * The link is up so send the appropriate
                         * DL_NOTIFY_IND.
                         */
                        str_notify_link_up(dsp);

                        speed = mac_stat_get(mh, MAC_STAT_IFSPEED);
                        str_notify_speed(dsp, (uint32_t)(speed / 1000ull));
                        break;
                }
                case LINK_STATE_DOWN:
                        /*
                         * The link is down so send the appropriate
                         * DL_NOTIFY_IND.
                         */
                        str_notify_link_down(dsp);
                        break;

                default:
                        break;
                }
                break;

        case MAC_NOTE_CAPAB_CHG:
                /*
                 * This notification is sent whenever the MAC resources
                 * change or capabilities change. We need to renegotiate
                 * the capabilities. Send the appropriate DL_NOTIFY_IND.
                 */
                str_notify_capab_reneg(dsp);
                break;

        case MAC_NOTE_SDU_SIZE: {
                uint_t  max_sdu;
                uint_t  multicast_sdu;
                mac_sdu_get2(dsp->ds_mh, NULL, &max_sdu, &multicast_sdu);
                str_notify_sdu_size(dsp, max_sdu, multicast_sdu);
                break;
        }

        case MAC_NOTE_FASTPATH_FLUSH:
                str_notify_fastpath_flush(dsp);
                break;

        /* Unused notifications */
        case MAC_NOTE_MARGIN:
                break;

        case MAC_NOTE_ALLOWED_IPS:
                str_notify_allowed_ips(dsp);
                break;

        default:
                ASSERT(B_FALSE);
                break;
        }
}

/*
 * This function is called via a taskq mechansim to process all control
 * messages on a per 'dsp' end point.
 */
static void
dld_wput_nondata_task(void *arg)
{
        dld_str_t       *dsp = arg;
        mblk_t          *mp;

        mutex_enter(&dsp->ds_lock);
        while (dsp->ds_pending_head != NULL) {
                mp = dsp->ds_pending_head;
                dsp->ds_pending_head = mp->b_next;
                mp->b_next = NULL;
                if (dsp->ds_pending_head == NULL)
                        dsp->ds_pending_tail = NULL;
                mutex_exit(&dsp->ds_lock);

                switch (DB_TYPE(mp)) {
                case M_PROTO:
                case M_PCPROTO:
                        dld_proto(dsp, mp);
                        break;
                case M_IOCTL:
                        dld_ioc(dsp, mp);
                        break;
                default:
                        ASSERT(0);
                }

                mutex_enter(&dsp->ds_lock);
        }
        ASSERT(dsp->ds_pending_tail == NULL);
        dsp->ds_dlpi_pending = 0;
        cv_broadcast(&dsp->ds_dlpi_pending_cv);
        mutex_exit(&dsp->ds_lock);
}

/*
 * Kernel thread to handle taskq dispatch failures in dld_wput_data. This
 * thread is started at boot time.
 */
static void
dld_taskq_dispatch(void)
{
        callb_cpr_t     cprinfo;
        dld_str_t       *dsp;

        CALLB_CPR_INIT(&cprinfo, &dld_taskq_lock, callb_generic_cpr,
            "dld_taskq_dispatch");
        mutex_enter(&dld_taskq_lock);

        while (!dld_taskq_quit) {
                dsp = list_head(&dld_taskq_list);
                while (dsp != NULL) {
                        list_remove(&dld_taskq_list, dsp);
                        mutex_exit(&dld_taskq_lock);
                        VERIFY(taskq_dispatch(dld_taskq, dld_wput_nondata_task,
                            dsp, TQ_SLEEP) != TASKQID_INVALID);
                        mutex_enter(&dld_taskq_lock);
                        dsp = list_head(&dld_taskq_list);
                }

                CALLB_CPR_SAFE_BEGIN(&cprinfo);
                cv_wait(&dld_taskq_cv, &dld_taskq_lock);
                CALLB_CPR_SAFE_END(&cprinfo, &dld_taskq_lock);
        }

        dld_taskq_done = B_TRUE;
        cv_signal(&dld_taskq_cv);
        CALLB_CPR_EXIT(&cprinfo);
        thread_exit();
}

/*
 * All control operations are serialized on the 'dsp' and are also funneled
 * through a taskq mechanism to ensure that subsequent processing has kernel
 * context and can safely use cv_wait.
 *
 * Mechanisms to handle taskq dispatch failures
 *
 * The only way to be sure that taskq dispatch does not fail is to either
 * specify TQ_SLEEP or to use a static taskq and prepopulate it with
 * some number of entries and make sure that the number of outstanding requests
 * are less than that number. We can't use TQ_SLEEP since we don't know the
 * context. Nor can we bound the total number of 'dsp' end points. So we are
 * unable to use either of the above schemes, and are forced to deal with
 * taskq dispatch failures. Note that even dynamic taskq could fail in
 * dispatch if TQ_NOSLEEP is specified, since this flag is translated
 * eventually to KM_NOSLEEP and kmem allocations could fail in the taskq
 * framework.
 *
 * We maintain a queue of 'dsp's that encountered taskq dispatch failure.
 * We also have a single global thread to retry the taskq dispatch. This
 * thread loops in 'dld_taskq_dispatch' and retries the taskq dispatch, but
 * uses TQ_SLEEP to ensure eventual success of the dispatch operation.
 */
static void
dld_wput_nondata(dld_str_t *dsp, mblk_t *mp)
{
        ASSERT(mp->b_next == NULL);
        mutex_enter(&dsp->ds_lock);
        if (dsp->ds_pending_head != NULL) {
                ASSERT(dsp->ds_dlpi_pending);
                dsp->ds_pending_tail->b_next = mp;
                dsp->ds_pending_tail = mp;
                mutex_exit(&dsp->ds_lock);
                return;
        }
        ASSERT(dsp->ds_pending_tail == NULL);
        dsp->ds_pending_head = dsp->ds_pending_tail = mp;
        /*
         * At this point if ds_dlpi_pending is set, it implies that the taskq
         * thread is still active and is processing the last message, though
         * the pending queue has been emptied.
         */
        if (dsp->ds_dlpi_pending) {
                mutex_exit(&dsp->ds_lock);
                return;
        }

        dsp->ds_dlpi_pending = 1;
        mutex_exit(&dsp->ds_lock);

        if (taskq_dispatch(dld_taskq, dld_wput_nondata_task, dsp,
            TQ_NOSLEEP) != TASKQID_INVALID)
                return;

        mutex_enter(&dld_taskq_lock);
        list_insert_tail(&dld_taskq_list, dsp);
        cv_signal(&dld_taskq_cv);
        mutex_exit(&dld_taskq_lock);
}

/*
 * Process an M_IOCTL message.
 */
static void
dld_ioc(dld_str_t *dsp, mblk_t *mp)
{
        uint_t                  cmd;

        cmd = ((struct iocblk *)mp->b_rptr)->ioc_cmd;
        ASSERT(dsp->ds_type == DLD_DLPI);

        switch (cmd) {
        case DLIOCNATIVE:
                ioc_native(dsp, mp);
                break;
        case DLIOCMARGININFO:
                ioc_margin(dsp, mp);
                break;
        case DLIOCRAW:
                ioc_raw(dsp, mp);
                break;
        case DLIOCHDRINFO:
                ioc_fast(dsp, mp);
                break;
        case DLIOCLOWLINK:
                ioc_lowlink(dsp, mp);
                break;
        default:
                ioc(dsp, mp);
        }
}

/*
 * DLIOCNATIVE
 */
static void
ioc_native(dld_str_t *dsp, mblk_t *mp)
{
        queue_t *q = dsp->ds_wq;
        const mac_info_t *mip = dsp->ds_mip;

        /*
         * Native mode can be enabled if it's disabled and if the
         * native media type is different.
         */
        if (!dsp->ds_native && mip->mi_media != mip->mi_nativemedia)
                dsp->ds_native = B_TRUE;

        if (dsp->ds_native)
                miocack(q, mp, 0, mip->mi_nativemedia);
        else
                miocnak(q, mp, 0, ENOTSUP);
}

/*
 * DLIOCMARGININFO
 */
static void
ioc_margin(dld_str_t *dsp, mblk_t *mp)
{
        queue_t *q = dsp->ds_wq;
        uint32_t margin;
        int err;

        if (dsp->ds_dlstate == DL_UNATTACHED) {
                err = EINVAL;
                goto failed;
        }
        if ((err = miocpullup(mp, sizeof (uint32_t))) != 0)
                goto failed;

        mac_margin_get(dsp->ds_mh, &margin);
        *((uint32_t *)mp->b_cont->b_rptr) = margin;
        miocack(q, mp, sizeof (uint32_t), 0);
        return;

failed:
        miocnak(q, mp, 0, err);
}

/*
 * DLIOCRAW
 */
static void
ioc_raw(dld_str_t *dsp, mblk_t *mp)
{
        queue_t *q = dsp->ds_wq;
        mac_perim_handle_t      mph;

        if (dsp->ds_mh == NULL) {
                dsp->ds_mode = DLD_RAW;
                miocack(q, mp, 0, 0);
                return;
        }

        mac_perim_enter_by_mh(dsp->ds_mh, &mph);
        if (dsp->ds_polling || dsp->ds_direct) {
                mac_perim_exit(mph);
                miocnak(q, mp, 0, EPROTO);
                return;
        }

        if (dsp->ds_mode != DLD_RAW && dsp->ds_dlstate == DL_IDLE) {
                /*
                 * Set the receive callback.
                 */
                dls_rx_set(dsp, dld_str_rx_raw, dsp);
        }

        /*
         * Note that raw mode is enabled.
         */
        dsp->ds_mode = DLD_RAW;
        mac_perim_exit(mph);

        miocack(q, mp, 0, 0);
}

/*
 * DLIOCHDRINFO
 */
static void
ioc_fast(dld_str_t *dsp, mblk_t *mp)
{
        dl_unitdata_req_t *dlp;
        off_t           off;
        size_t          len;
        const uint8_t   *addr;
        uint16_t        sap;
        mblk_t          *nmp;
        mblk_t          *hmp;
        uint_t          addr_length;
        queue_t         *q = dsp->ds_wq;
        int             err;
        mac_perim_handle_t      mph;

        if (dld_opt & DLD_OPT_NO_FASTPATH) {
                err = ENOTSUP;
                goto failed;
        }

        /*
         * DLIOCHDRINFO should only come from IP. The one initiated from
         * user-land should not be allowed.
         */
        if (((struct iocblk *)mp->b_rptr)->ioc_cr != kcred) {
                err = EINVAL;
                goto failed;
        }

        nmp = mp->b_cont;
        if (nmp == NULL || MBLKL(nmp) < sizeof (dl_unitdata_req_t) ||
            (dlp = (dl_unitdata_req_t *)nmp->b_rptr,
            dlp->dl_primitive != DL_UNITDATA_REQ)) {
                err = EINVAL;
                goto failed;
        }

        off = dlp->dl_dest_addr_offset;
        len = dlp->dl_dest_addr_length;

        if (!MBLKIN(nmp, off, len)) {
                err = EINVAL;
                goto failed;
        }

        if (dsp->ds_dlstate != DL_IDLE) {
                err = ENOTSUP;
                goto failed;
        }

        addr_length = dsp->ds_mip->mi_addr_length;
        if (len != addr_length + sizeof (uint16_t)) {
                err = EINVAL;
                goto failed;
        }

        addr = nmp->b_rptr + off;
        sap = *(uint16_t *)(nmp->b_rptr + off + addr_length);

        if ((hmp = dls_header(dsp, addr, sap, 0, NULL)) == NULL) {
                err = ENOMEM;
                goto failed;
        }

        /*
         * This ioctl might happen concurrently with a direct call to dld_capab
         * that tries to enable direct and/or poll capabilities. Since the
         * stack does not serialize them, we do so here to avoid mixing
         * the callbacks.
         */
        mac_perim_enter_by_mh(dsp->ds_mh, &mph);
        if (dsp->ds_mode != DLD_FASTPATH) {
                /*
                 * Set the receive callback (unless polling is enabled).
                 */
                if (!dsp->ds_polling && !dsp->ds_direct)
                        dls_rx_set(dsp, dld_str_rx_fastpath, dsp);

                /*
                 * Note that fast-path mode is enabled.
                 */
                dsp->ds_mode = DLD_FASTPATH;
        }
        mac_perim_exit(mph);

        freemsg(nmp->b_cont);
        nmp->b_cont = hmp;

        miocack(q, mp, MBLKL(nmp) + MBLKL(hmp), 0);
        return;
failed:
        miocnak(q, mp, 0, err);
}

/*
 * DLIOCLOWLINK: request actual link state changes. When the
 * link is part of a bridge instance the client receives actual
 * link state changes and not the aggregate link status. Used by
 * the bridging daemon (bridged) for proper RSTP operation.
 */
static void
ioc_lowlink(dld_str_t *dsp, mblk_t *mp)
{
        queue_t *q = dsp->ds_wq;
        int err;

        if ((err = miocpullup(mp, sizeof (int))) != 0) {
                miocnak(q, mp, 0, err);
        } else {
                /* LINTED: alignment */
                dsp->ds_lowlink = *(boolean_t *)mp->b_cont->b_rptr;
                miocack(q, mp, 0, 0);
        }
}

/*
 * Catch-all handler.
 */
static void
ioc(dld_str_t *dsp, mblk_t *mp)
{
        queue_t *q = dsp->ds_wq;

        if (dsp->ds_dlstate == DL_UNATTACHED) {
                miocnak(q, mp, 0, EINVAL);
                return;
        }
        mac_ioctl(dsp->ds_mh, q, mp);
}