path: root/usr/src/uts/common/io/softmac/softmac_capab.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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/types.h>
#include <sys/mac.h>
#include <sys/softmac_impl.h>

typedef struct softmac_capab_ops {
	int	(*sc_hcksum_ack)(void *, t_uscalar_t);
	int	(*sc_zcopy_ack)(void *, t_uscalar_t);
	int	(*sc_mdt_ack)(void *, dl_capab_mdt_t *);
} softmac_capab_ops_t;

static int	dl_capab(ldi_handle_t, mblk_t **);
static int	softmac_fill_hcksum_ack(void *, t_uscalar_t);
static int	softmac_fill_zcopy_ack(void *, t_uscalar_t);
static int	softmac_fill_mdt_ack(void *, dl_capab_mdt_t *);
static int	softmac_adv_hcksum_ack(void *, t_uscalar_t);
static int	softmac_adv_zcopy_ack(void *, t_uscalar_t);
static int	softmac_adv_mdt_ack(void *, dl_capab_mdt_t *);
static int	softmac_enable_hcksum_ack(void *, t_uscalar_t);
static int	softmac_enable_mdt_ack(void *, dl_capab_mdt_t *);
static int	softmac_capab_send(softmac_lower_t *, boolean_t);
static int	i_capab_ack(mblk_t *, queue_t *, softmac_capab_ops_t *, void *);
static int	i_capab_id_ack(mblk_t *, dl_capability_sub_t *, queue_t *,
    softmac_capab_ops_t *, void *);
static int	i_capab_sub_ack(mblk_t *, dl_capability_sub_t *, queue_t *,
    softmac_capab_ops_t *, void *);
static int	i_capab_hcksum_ack(dl_capab_hcksum_t *, queue_t *,
    softmac_capab_ops_t *, void *);
static int	i_capab_zcopy_ack(dl_capab_zerocopy_t *, queue_t *,
    softmac_capab_ops_t *, void *);
static int	i_capab_mdt_ack(dl_capab_mdt_t *, queue_t *,
    softmac_capab_ops_t *, void *);
static int	i_capab_hcksum_verify(dl_capab_hcksum_t *, queue_t *);
static int	i_capab_zcopy_verify(dl_capab_zerocopy_t *, queue_t *);
static int	i_capab_mdt_verify(dl_capab_mdt_t *, queue_t *);

static softmac_capab_ops_t softmac_fill_capab_ops =
{
	softmac_fill_hcksum_ack,
	softmac_fill_zcopy_ack,
	softmac_fill_mdt_ack,
};

static softmac_capab_ops_t softmac_adv_capab_ops =
{
	softmac_adv_hcksum_ack,
	softmac_adv_zcopy_ack,
	softmac_adv_mdt_ack
};

static softmac_capab_ops_t softmac_enable_capab_ops =
{
	softmac_enable_hcksum_ack,
	NULL,
	softmac_enable_mdt_ack
};

int
softmac_fill_capab(ldi_handle_t lh, softmac_t *softmac)
{
	mblk_t			*mp = NULL;
	union DL_primitives	*prim;
	int			err = 0;

	if ((err = dl_capab(lh, &mp)) != 0)
		goto exit;

	prim = (union DL_primitives *)mp->b_rptr;
	if (prim->dl_primitive == DL_ERROR_ACK) {
		err = -1;
		goto exit;
	}

	err = i_capab_ack(mp, NULL, &softmac_fill_capab_ops, softmac);

exit:
	freemsg(mp);
	return (err);
}

static int
dl_capab(ldi_handle_t lh, mblk_t **mpp)
{
	dl_capability_req_t	*capb;
	union DL_primitives	*dl_prim;
	mblk_t			*mp;
	int			err;

	if ((mp = allocb(sizeof (dl_capability_req_t), BPRI_MED)) == NULL)
		return (ENOMEM);
	mp->b_datap->db_type = M_PROTO;

	capb = (dl_capability_req_t *)mp->b_wptr;
	mp->b_wptr += sizeof (dl_capability_req_t);
	bzero(mp->b_rptr, sizeof (dl_capability_req_t));
	capb->dl_primitive = DL_CAPABILITY_REQ;

	(void) ldi_putmsg(lh, mp);
	if ((err = ldi_getmsg(lh, &mp, (timestruc_t *)NULL)) != 0)
		return (err);

	dl_prim = (union DL_primitives *)mp->b_rptr;
	switch (dl_prim->dl_primitive) {
	case DL_CAPABILITY_ACK:
		if (MBLKL(mp) < DL_CAPABILITY_ACK_SIZE) {
			printf("dl_capability: DL_CAPABILITY_ACK "
			    "protocol err\n");
			break;
		}
		*mpp = mp;
		return (0);

	case DL_ERROR_ACK:
		if (MBLKL(mp) < DL_ERROR_ACK_SIZE) {
			printf("dl_capability: DL_ERROR_ACK protocol err\n");
			break;
		}
		if (((dl_error_ack_t *)dl_prim)->dl_error_primitive !=
		    DL_CAPABILITY_REQ) {
			printf("dl_capability: DL_ERROR_ACK rtnd prim %u\n",
			    ((dl_error_ack_t *)dl_prim)->dl_error_primitive);
			break;
		}

		*mpp = mp;
		return (0);

	default:
		printf("dl_capability: bad ACK header %u\n",
		    dl_prim->dl_primitive);
		break;
	}

	freemsg(mp);
	return (-1);
}

static int
softmac_fill_hcksum_ack(void *arg, t_uscalar_t flags)
{
	softmac_t	*softmac = (softmac_t *)arg;

	/*
	 * There are two types of acks we process here:
	 * 1. acks in reply to a (first form) generic capability req
	 *    (no ENABLE flag set)
	 * 2. acks in reply to a ENABLE capability req.
	 *    (ENABLE flag set)
	 * Only the first type should be expected here.
	 */

	if (flags & HCKSUM_ENABLE) {
		cmn_err(CE_WARN, "softmac_fill_hcksum_ack: unexpected "
		    "HCKSUM_ENABLE flag in hardware checksum capability");
	} else if (flags & (HCKSUM_INET_PARTIAL | HCKSUM_INET_FULL_V4 |
	    HCKSUM_INET_FULL_V6 | HCKSUM_IPHDRCKSUM)) {
		softmac->smac_capab_flags |= MAC_CAPAB_HCKSUM;
		softmac->smac_hcksum_txflags = flags;
	}
	return (0);
}

static int
softmac_fill_zcopy_ack(void *arg, t_uscalar_t flags)
{
	softmac_t	*softmac = (softmac_t *)arg;

	ASSERT(flags == DL_CAPAB_VMSAFE_MEM);
	softmac->smac_capab_flags &= (~MAC_CAPAB_NO_ZCOPY);
	return (0);
}

static int
softmac_fill_mdt_ack(void *arg, dl_capab_mdt_t *mdt)
{
	softmac_t *softmac = (softmac_t *)arg;

	/*
	 * There are two types of acks we process here:
	 * 1. acks in reply to a (first form) generic capability req
	 *    (ENABLE flag might be set by some drivers)
	 * 2. acks in reply to a ENABLE capability req.
	 *    (ENABLE flag set)
	 */

	ASSERT(mdt->mdt_version == MDT_VERSION_2);
	softmac->smac_mdt = B_TRUE;
	softmac->smac_mdt_capab.mdt_hdr_head = mdt->mdt_hdr_head;
	softmac->smac_mdt_capab.mdt_hdr_tail = mdt->mdt_hdr_tail;
	softmac->smac_mdt_capab.mdt_max_pld = mdt->mdt_max_pld;
	softmac->smac_mdt_capab.mdt_span_limit = mdt->mdt_span_limit;
	return (0);
}

int
softmac_capab_enable(softmac_lower_t *slp)
{
	softmac_t	*softmac = slp->sl_softmac;
	int		err;

	if (softmac->smac_no_capability_req)
		return (0);

	/*
	 * Send DL_CAPABILITY_REQ to get capability advertisement.
	 */
	if ((err = softmac_capab_send(slp, B_FALSE)) != 0)
		return (err);

	/*
	 * Send DL_CAPABILITY_REQ to enable specific capabilities.
	 */
	if ((err = softmac_capab_send(slp, B_TRUE)) != 0)
		return (err);

	return (0);
}

static int
softmac_capab_send(softmac_lower_t *slp, boolean_t enable)
{
	softmac_t		*softmac;
	dl_capability_req_t	*capb;
	dl_capability_sub_t	*subcapb;
	mblk_t			*reqmp, *ackmp;
	int			err;
	size_t			size = 0;

	softmac = slp->sl_softmac;

	if (enable) {
		/* No need to enable DL_CAPAB_ZEROCOPY */
		if (softmac->smac_capab_flags & MAC_CAPAB_HCKSUM)
			size += sizeof (dl_capability_sub_t) +
			    sizeof (dl_capab_hcksum_t);

		if (softmac->smac_mdt) {
			if (!(softmac->smac_mdt_capab.mdt_flags &
			    DL_CAPAB_MDT_ENABLE)) {
				/*
				 * The MDT capability was not enabled for the
				 * first time, enable it now.
				 */
				size += sizeof (dl_capability_sub_t) +
				    sizeof (dl_capab_mdt_t);
			}
		}

		if (size == 0)
			return (0);
	}

	/*
	 * Create DL_CAPABILITY_REQ message and send it down
	 */
	reqmp = allocb(sizeof (dl_capability_req_t) + size, BPRI_MED);
	if (reqmp == NULL)
		return (ENOMEM);

	bzero(reqmp->b_rptr, sizeof (dl_capability_req_t) + size);

	DB_TYPE(reqmp) = M_PROTO;
	reqmp->b_wptr = reqmp->b_rptr + sizeof (dl_capability_req_t) + size;

	capb = (dl_capability_req_t *)reqmp->b_rptr;
	capb->dl_primitive = DL_CAPABILITY_REQ;

	if (!enable)
		goto output;

	capb->dl_sub_offset = sizeof (dl_capability_req_t);

	if (softmac->smac_capab_flags & MAC_CAPAB_HCKSUM) {
		dl_capab_hcksum_t *hck_subcapp;

		size = sizeof (dl_capability_sub_t) +
		    sizeof (dl_capab_hcksum_t);
		capb->dl_sub_length += size;

		subcapb = (dl_capability_sub_t *)(capb + 1);
		subcapb->dl_cap = DL_CAPAB_HCKSUM;
		subcapb->dl_length = sizeof (dl_capab_hcksum_t);
		hck_subcapp = (dl_capab_hcksum_t *)(subcapb + 1);
		hck_subcapp->hcksum_version = HCKSUM_VERSION_1;
		hck_subcapp->hcksum_txflags =
		    softmac->smac_hcksum_txflags | HCKSUM_ENABLE;
	}

	if (softmac->smac_mdt) {
		if (!(softmac->smac_mdt_capab.mdt_flags &
		    DL_CAPAB_MDT_ENABLE)) {
			dl_capab_mdt_t *mdt_subcapp;

			size = sizeof (dl_capability_sub_t) +
			    sizeof (dl_capab_mdt_t);
			capb->dl_sub_length += size;

			subcapb = (dl_capability_sub_t *)
			    ((uint8_t *)(subcapb + 1) + subcapb->dl_length);

			subcapb->dl_cap = DL_CAPAB_MDT;
			subcapb->dl_length = sizeof (dl_capab_mdt_t);
			mdt_subcapp = (dl_capab_mdt_t *)(subcapb + 1);
			mdt_subcapp->mdt_version = MDT_VERSION_2;
			mdt_subcapp->mdt_flags =
			    (softmac->smac_mdt_capab.mdt_flags |
			    DL_CAPAB_MDT_ENABLE);
			mdt_subcapp->mdt_hdr_head =
			    softmac->smac_mdt_capab.mdt_hdr_head;
			mdt_subcapp->mdt_hdr_tail =
			    softmac->smac_mdt_capab.mdt_hdr_tail;
			mdt_subcapp->mdt_max_pld =
			    softmac->smac_mdt_capab.mdt_max_pld;
			mdt_subcapp->mdt_span_limit =
			    softmac->smac_mdt_capab.mdt_span_limit;
		}
	}

output:
	err = softmac_proto_tx(slp, reqmp, &ackmp);
	if (err == 0) {
		if (enable) {
			err = i_capab_ack(ackmp, NULL,
			    &softmac_enable_capab_ops, softmac);
		} else {
			err = i_capab_ack(ackmp, NULL,
			    &softmac_adv_capab_ops, softmac);
		}
	}
	freemsg(ackmp);

	return (err);
}

static int
softmac_adv_hcksum_ack(void *arg, t_uscalar_t flags)
{
	softmac_t	*softmac = (softmac_t *)arg;

	/*
	 * There are two types of acks we process here:
	 * 1. acks in reply to a (first form) generic capability req
	 *    (no ENABLE flag set)
	 * 2. acks in reply to a ENABLE capability req.
	 *    (ENABLE flag set)
	 * Only the first type should be expected here.
	 */

	if (flags & HCKSUM_ENABLE) {
		cmn_err(CE_WARN, "softmac_adv_hcksum_ack: unexpected "
		    "HCKSUM_ENABLE flag in hardware checksum capability");
		return (-1);
	} else if (flags & (HCKSUM_INET_PARTIAL | HCKSUM_INET_FULL_V4 |
	    HCKSUM_INET_FULL_V6 | HCKSUM_IPHDRCKSUM)) {
		/*
		 * The acknowledgement should be the same as we got when
		 * the softmac is created.
		 */
		if (!(softmac->smac_capab_flags & MAC_CAPAB_HCKSUM)) {
			ASSERT(B_FALSE);
			return (-1);
		}
		if (softmac->smac_hcksum_txflags != flags) {
			ASSERT(B_FALSE);
			return (-1);
		}
	}

	return (0);
}

static int
softmac_adv_zcopy_ack(void *arg, t_uscalar_t flags)
{
	softmac_t	*softmac = (softmac_t *)arg;

	/*
	 * The acknowledgement should be the same as we got when
	 * the softmac is created.
	 */
	ASSERT(flags == DL_CAPAB_VMSAFE_MEM);
	if (softmac->smac_capab_flags & MAC_CAPAB_NO_ZCOPY) {
		ASSERT(B_FALSE);
		return (-1);
	}

	return (0);
}

static int
softmac_adv_mdt_ack(void *arg, dl_capab_mdt_t *mdt)
{
	softmac_t *softmac = (softmac_t *)arg;

	/*
	 * The acknowledgement should be the same as we got when
	 * the softmac is created.
	 */
	if (!softmac->smac_mdt) {
		ASSERT(B_FALSE);
		return (-1);
	}

	if ((softmac->smac_mdt_capab.mdt_hdr_head != mdt->mdt_hdr_head) ||
	    (softmac->smac_mdt_capab.mdt_hdr_tail != mdt->mdt_hdr_tail) ||
	    (softmac->smac_mdt_capab.mdt_max_pld != mdt->mdt_max_pld) ||
	    (softmac->smac_mdt_capab.mdt_span_limit != mdt->mdt_span_limit)) {
		ASSERT(B_FALSE);
		return (-1);
	}
	/*
	 * We need the mdt_flags field to know whether an additional
	 * DL_CAPAB_MDT_ENABLE is necessary.
	 */
	softmac->smac_mdt_capab.mdt_flags = mdt->mdt_flags;
	return (0);
}

static int
softmac_enable_hcksum_ack(void *arg, t_uscalar_t flags)
{
	softmac_t	*softmac = (softmac_t *)arg;

	/*
	 * There are two types of acks we process here:
	 * 1. acks in reply to a (first form) generic capability req
	 *    (no ENABLE flag set)
	 * 2. acks in reply to a ENABLE capability req.
	 *    (ENABLE flag set)
	 * Only the second type should be expected here.
	 */

	if (flags & HCKSUM_ENABLE) {
		if ((flags & ~HCKSUM_ENABLE) != softmac->smac_hcksum_txflags) {
			cmn_err(CE_WARN, "softmac_enable_hcksum_ack: unexpected"
			    " hardware capability flag value 0x%x", flags);
			return (-1);
		}
	} else {
		cmn_err(CE_WARN, "softmac_enable_hcksum_ack: "
		    "hardware checksum flag HCKSUM_ENABLE is not set");
		return (-1);
	}

	return (0);
}

static int
softmac_enable_mdt_ack(void *arg, dl_capab_mdt_t *mdt)
{
	softmac_t	*softmac = (softmac_t *)arg;

	/*
	 * There are two types of acks we process here:
	 * 1. acks in reply to a (first form) generic capability req
	 *    (no ENABLE flag set)
	 * 2. acks in reply to a ENABLE capability req.
	 *    (ENABLE flag set)
	 * Only the second type should be expected here.
	 */

	if (mdt->mdt_flags & DL_CAPAB_MDT_ENABLE) {
		if ((softmac->smac_mdt_capab.mdt_hdr_head !=
		    mdt->mdt_hdr_head) ||
		    (softmac->smac_mdt_capab.mdt_hdr_tail !=
		    mdt->mdt_hdr_tail) ||
		    (softmac->smac_mdt_capab.mdt_max_pld !=
		    mdt->mdt_max_pld) ||
		    (softmac->smac_mdt_capab.mdt_span_limit !=
		    mdt->mdt_span_limit)) {
			cmn_err(CE_WARN, "softmac_enable_mdt_ack: "
			    "unexpected MDT capability value");
			return (-1);
		}
		softmac->smac_mdt_capab.mdt_flags = mdt->mdt_flags;
	} else {
		cmn_err(CE_WARN, "softmac_enable_mdt_ack: "
		    "MDT flag DL_CAPAB_MDT_ENABLE is not set");
		return (-1);
	}

	return (0);
}

static int
i_capab_ack(mblk_t *mp, queue_t *q, softmac_capab_ops_t *op, void *arg)
{
	union DL_primitives	*prim;
	dl_capability_ack_t	*cap;
	dl_capability_sub_t	*sub, *end;
	int			err = 0;

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

	cap = (dl_capability_ack_t *)prim;
	if (cap->dl_sub_length == 0)
		goto exit;

	/* Is dl_sub_length correct? */
	if ((sizeof (*cap) + cap->dl_sub_length) > MBLKL(mp)) {
		err = EINVAL;
		goto exit;
	}

	sub = (dl_capability_sub_t *)((caddr_t)cap + cap->dl_sub_offset);
	end = (dl_capability_sub_t *)((caddr_t)cap + cap->dl_sub_length
	    - sizeof (*sub));
	for (; (sub <= end) && (err == 0); ) {
		switch (sub->dl_cap) {
		case DL_CAPAB_ID_WRAPPER:
			err = i_capab_id_ack(mp, sub, q, op, arg);
			break;
		default:
			err = i_capab_sub_ack(mp, sub, q, op, arg);
			break;
		}
		sub = (dl_capability_sub_t *)((caddr_t)sub + sizeof (*sub)
		    + sub->dl_length);
	}

exit:
	return (err);
}

static int
i_capab_id_ack(mblk_t *mp, dl_capability_sub_t *outers,
    queue_t *q, softmac_capab_ops_t *op, void *arg)
{
	dl_capab_id_t		*capab_id;
	dl_capability_sub_t	*inners;
	caddr_t			capend;
	int			err = EINVAL;

	ASSERT(outers->dl_cap == DL_CAPAB_ID_WRAPPER);

	capend = (caddr_t)(outers + 1) + outers->dl_length;
	if (capend > (caddr_t)mp->b_wptr) {
		cmn_err(CE_WARN, "i_capab_id_ack: malformed "
		    "sub-capability too long");
		return (err);
	}

	capab_id = (dl_capab_id_t *)(outers + 1);

	if (outers->dl_length < sizeof (*capab_id) ||
	    (inners = &capab_id->id_subcap,
	    inners->dl_length > (outers->dl_length - sizeof (*inners)))) {
		cmn_err(CE_WARN, "i_capab_id_ack: malformed "
		    "encapsulated capab type %d too long",
		    inners->dl_cap);
		return (err);
	}

	if ((q != NULL) && (!dlcapabcheckqid(&capab_id->id_mid, q))) {
		cmn_err(CE_WARN, "i_capab_id_ack: pass-thru module(s) "
		    "detected, discarding capab type %d", inners->dl_cap);
		return (err);
	}

	/* Process the encapsulated sub-capability */
	return (i_capab_sub_ack(mp, inners, q, op, arg));
}

static int
i_capab_sub_ack(mblk_t *mp, dl_capability_sub_t *sub, queue_t *q,
    softmac_capab_ops_t *op, void *arg)
{
	caddr_t			capend;
	dl_capab_hcksum_t	*hcksum;
	dl_capab_zerocopy_t	*zcopy;
	dl_capab_mdt_t		*mdt;
	int			err = 0;

	capend = (caddr_t)(sub + 1) + sub->dl_length;
	if (capend > (caddr_t)mp->b_wptr) {
		cmn_err(CE_WARN, "i_capab_sub_ack: "
		    "malformed sub-capability too long");
		return (EINVAL);
	}

	switch (sub->dl_cap) {
	case DL_CAPAB_HCKSUM:
		hcksum = (dl_capab_hcksum_t *)(sub + 1);
		err = i_capab_hcksum_ack(hcksum, q, op, arg);
		break;

	case DL_CAPAB_ZEROCOPY:
		zcopy = (dl_capab_zerocopy_t *)(sub + 1);
		err = i_capab_zcopy_ack(zcopy, q, op, arg);
		break;

	case DL_CAPAB_MDT:
		mdt = (dl_capab_mdt_t *)(sub + 1);
		err = i_capab_mdt_ack(mdt, q, op, arg);
		break;

	default:
		cmn_err(CE_WARN, "i_capab_sub_ack: unknown capab type %d",
		    sub->dl_cap);
		err = EINVAL;
	}

	return (err);
}

static int
i_capab_hcksum_ack(dl_capab_hcksum_t *hcksum, queue_t *q,
    softmac_capab_ops_t *op, void *arg)
{
	t_uscalar_t		flags;
	int			err = 0;

	if ((err = i_capab_hcksum_verify(hcksum, q)) != 0)
		return (err);

	flags = hcksum->hcksum_txflags;

	if (!(flags & (HCKSUM_INET_PARTIAL | HCKSUM_INET_FULL_V4 |
	    HCKSUM_INET_FULL_V6 | HCKSUM_IPHDRCKSUM | HCKSUM_ENABLE))) {
		cmn_err(CE_WARN, "i_capab_hcksum_ack: invalid "
		    "hardware checksum capability flags 0x%x", flags);
		return (EINVAL);
	}

	if (op->sc_hcksum_ack)
		return (op->sc_hcksum_ack(arg, flags));
	else {
		cmn_err(CE_WARN, "i_capab_hcksum_ack: unexpected hardware "
		    "checksum acknowledgement");
		return (EINVAL);
	}
}

static int
i_capab_zcopy_ack(dl_capab_zerocopy_t *zcopy, queue_t *q,
    softmac_capab_ops_t *op, void *arg)
{
	t_uscalar_t		flags;
	int			err = 0;

	if ((err = i_capab_zcopy_verify(zcopy, q)) != 0)
		return (err);

	flags = zcopy->zerocopy_flags;
	if (!(flags & DL_CAPAB_VMSAFE_MEM)) {
		cmn_err(CE_WARN, "i_capab_zcopy_ack: invalid zcopy capability "
		    "flags 0x%x", flags);
		return (EINVAL);
	}
	if (op->sc_zcopy_ack)
		return (op->sc_zcopy_ack(arg, flags));
	else {
		cmn_err(CE_WARN, "i_capab_zcopy_ack: unexpected zcopy "
		    "acknowledgement");
		return (EINVAL);
	}
}

static int
i_capab_mdt_ack(dl_capab_mdt_t *mdt, queue_t *q,
    softmac_capab_ops_t *op, void *arg)
{
	int	err;

	if ((err = i_capab_mdt_verify(mdt, q)) != 0)
		return (err);

	if (op->sc_mdt_ack)
		return (op->sc_mdt_ack(arg, mdt));
	else {
		cmn_err(CE_WARN, "i_capab_mdt_ack: unexpected MDT "
		    "acknowledgement");
		return (EINVAL);
	}
}

static int
i_capab_hcksum_verify(dl_capab_hcksum_t *hcksum, queue_t *q)
{
	if (hcksum->hcksum_version != HCKSUM_VERSION_1) {
		cmn_err(CE_WARN, "i_capab_hcksum_verify: "
		    "unsupported hardware checksum capability (version %d, "
		    "expected %d)", hcksum->hcksum_version, HCKSUM_VERSION_1);
		return (-1);
	}

	if ((q != NULL) && !dlcapabcheckqid(&hcksum->hcksum_mid, q)) {
		cmn_err(CE_WARN, "i_capab_hcksum_verify: unexpected pass-thru "
		    "module detected; hardware checksum capability discarded");
		return (-1);
	}
	return (0);
}

static int
i_capab_zcopy_verify(dl_capab_zerocopy_t *zcopy, queue_t *q)
{
	if (zcopy->zerocopy_version != ZEROCOPY_VERSION_1) {
		cmn_err(CE_WARN, "i_capab_zcopy_verify: unsupported zcopy "
		    "capability (version %d, expected %d)",
		    zcopy->zerocopy_version, ZEROCOPY_VERSION_1);
		return (-1);
	}

	if ((q != NULL) && !dlcapabcheckqid(&zcopy->zerocopy_mid, q)) {
		cmn_err(CE_WARN, "i_capab_zcopy_verify: unexpected pass-thru "
		    "module detected; zcopy checksum capability discarded");
		return (-1);
	}
	return (0);
}

static int
i_capab_mdt_verify(dl_capab_mdt_t *mdt, queue_t *q)
{
	if (mdt->mdt_version != MDT_VERSION_2) {
		cmn_err(CE_WARN, "i_capab_mdt_verify: unsupported MDT "
		    "capability (version %d, expected %d)",
		    mdt->mdt_version, MDT_VERSION_2);
		return (-1);
	}

	if ((q != NULL) && !dlcapabcheckqid(&mdt->mdt_mid, q)) {
		cmn_err(CE_WARN, "i_capab_mdt_verify: unexpected pass-thru "
		    "module detected; MDT capability discarded");
		return (-1);
	}
	return (0);
}