usr/src/uts/common/io/drcompat.c - illumos-gate - Gitiles

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

 /*
  * Standard module for handling DLPI Style 2 attach/detach
  */

 #include <sys/types.h>
 #include <sys/conf.h>
 #include <sys/modctl.h>
 #include <sys/cmn_err.h>
 #include <sys/sunddi.h>
 #include <sys/esunddi.h>
 #include <sys/strsubr.h>
 #include <sys/ddi.h>
 #include <sys/dlpi.h>
 #include <sys/strsun.h>
 #include <sys/policy.h>

 static struct streamtab drstab;

 static struct fmodsw fsw = {
 	DRMODNAME,
 	&drstab,
 	D_MP
 };


 /*
  * Module linkage information for the kernel.
  */

 static struct modlstrmod modlstrmod = {
 	&mod_strmodops, "dr compatibility for DLPI style 2 drivers", &fsw
 };


 static struct modlinkage modlinkage = {
 	MODREV_1, &modlstrmod, 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));
 }


 static int	dropen(queue_t *, dev_t *, int, int, cred_t *);
 static int	drclose(queue_t *, int, cred_t *);
 static int	drrput(queue_t *, mblk_t *);
 static int	drwput(queue_t *, mblk_t *);

 static struct module_info drinfo = {
 	0,
 	DRMODNAME,
 	0,
 	INFPSZ,
 	1,
 	0
 };

 static struct qinit drrinit = {
 	(int (*)())drrput,
 	NULL,
 	dropen,
 	drclose,
 	NULL,
 	&drinfo
 };

 static struct qinit drwinit = {
 	(int (*)())drwput,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
 	&drinfo
 };

 static struct streamtab drstab = {
 	&drrinit,
 	&drwinit,
 	NULL,
 	NULL
 };

 /*
  * This module is pushed directly on top of the bottom driver
  * in a DLPI style-2 stream by stropen(). It intercepts
  * DL_ATTACH_REQ/DL_DETACH_REQ messages on the write side
  * and acks on the read side, calls qassociate where needed.
  * The primary purpose is to workaround a DR race condition
  * affecting non-DDI compliant DLPI style 2 drivers, which may
  * cause the system to panic.
  *
  * The following action is taken:
  * Write side (drwput):
  *	attach request:	hold driver instance assuming ppa == instance.
  *		This way, the instance cannot be detached while the
  *		driver is processing DL_ATTACH_REQ.
  *
  *		On a successful hold, store the dip in a ring buffer
  *		to be processed lated by the read side.
  *		If hold fails (most likely ppa != instance), we store
  *		NULL in the ring buffer and read side won't take
  *		any action on ack.
  *
  * Read side (drrput):
  *	attach success: if (dip held on write side) associate queue with dip
  *	attach failure:	if (dip held on write side) release hold on dip
  *	detach success: associate queue with NULL
  *	detach failure:	do nothing
  *
  * The module assumes that incoming DL_ATTACH_REQ/DL_DETACH_REQ
  * messages are ordered (non-concurrent) and the bottom
  * driver processes them and sends acknowledgements in the same
  * order. This assumption is reasonable because concurrent
  * association results in non-deterministic queue behavior.
  * The module is coded carefully such that unordered messages
  * do not result in a system panic.
  *
  * The module handles multiple outstanding messages queued
  * in the bottom driver. Messages processed on the write side
  * but not yet arrived at read side are placed in the ring buffer
  * dr_dip[], between dr_nfirst and dr_nlast. The write side is
  * producer and the read side is the consumer. The buffer is full
  * when dr_nfirst == dr_nlast.
  *
  * The current size of the ring buffer is 64 (MAX_DLREQS) per stream.
  * During normal testing, we have not seen outstanding messages
  * above 10.
  */

 #define	MAX_DLREQS	64
 #define	INCR(x)		{(x)++; if ((x) >= MAX_DLREQS) (x) = 0; }

 struct drstate {
 	kmutex_t dr_lock;
 	major_t dr_major;
 	int dr_nfirst;
 	int dr_nlast;
 	dev_info_t *dr_dip[MAX_DLREQS];
 };

 /* ARGSUSED1 */
 static int
 dropen(queue_t *q, dev_t *devp, int oflag, int sflag, cred_t *crp)
 {
 	struct drstate *dsp;

 	if (sflag != MODOPEN) {	/* must be a pushed module */
 		return (EINVAL);
 	}

 	if (secpolicy_net_rawaccess(crp) != 0) {
 		return (EPERM);
 	}

 	if (q->q_ptr != NULL) {
 		return (0);	/* already open */
 	}

 	dsp = kmem_zalloc(sizeof (*dsp), KM_SLEEP);
 	dsp->dr_major = getmajor(*devp);
 	mutex_init(&dsp->dr_lock, NULL, MUTEX_DEFAULT, NULL);
 	q->q_ptr = OTHERQ(q)->q_ptr = dsp;
 	qprocson(q);
 	ddi_assoc_queue_with_devi(q, NULL);
 	return (0);
 }

 /* ARGSUSED1 */
 static int
 drclose(queue_t *q, int cflag, cred_t *crp)
 {
 	struct drstate *dsp = q->q_ptr;

 	ASSERT(dsp);
 	ddi_assoc_queue_with_devi(q, NULL);
 	qprocsoff(q);

 	mutex_destroy(&dsp->dr_lock);
 	kmem_free(dsp, sizeof (*dsp));
 	q->q_ptr = NULL;

 	return (0);
 }

 static int
 drrput(queue_t *q, mblk_t *mp)
 {
 	struct drstate *dsp;
 	union DL_primitives *dlp;
 	dev_info_t *dip;

 	switch (DB_TYPE(mp)) {
 	case M_PROTO:
 	case M_PCPROTO:
 		break;
 	default:
 		putnext(q, mp);
 		return (0);
 	}

 	/* make sure size is sufficient for dl_primitive */
 	if (MBLKL(mp) < sizeof (t_uscalar_t)) {
 		putnext(q, mp);
 		return (0);
 	}

 	dlp = (union DL_primitives *)mp->b_rptr;
 	switch (dlp->dl_primitive) {
 	case DL_OK_ACK: {
 		/* check for proper size, let upper layer deal with error */
 		if (MBLKL(mp) < DL_OK_ACK_SIZE) {
 			putnext(q, mp);
 			return (0);
 		}

 		dsp = q->q_ptr;
 		switch (dlp->ok_ack.dl_correct_primitive) {
 		case DL_ATTACH_REQ:
 			/*
 			 * ddi_assoc_queue_with_devi() will hold dip,
 			 * so release after association.
 			 *
 			 * dip is NULL means we didn't hold dip on read side.
 			 * (unlikely, but possible), so we do nothing.
 			 */
 			mutex_enter(&dsp->dr_lock);
 			dip = dsp->dr_dip[dsp->dr_nlast];
 			dsp->dr_dip[dsp->dr_nlast] = NULL;
 			INCR(dsp->dr_nlast);
 			mutex_exit(&dsp->dr_lock);
 			if (dip) {
 				ddi_assoc_queue_with_devi(q, dip);
 				ddi_release_devi(dip);
 			}
 			break;

 		case DL_DETACH_REQ:
 			ddi_assoc_queue_with_devi(q, NULL);
 			break;
 		default:
 			break;
 		}
 		break;
 	}
 	case DL_ERROR_ACK:
 		if (dlp->error_ack.dl_error_primitive != DL_ATTACH_REQ)
 			break;

 		dsp = q->q_ptr;
 		mutex_enter(&dsp->dr_lock);
 		dip = dsp->dr_dip[dsp->dr_nlast];
 		dsp->dr_dip[dsp->dr_nlast] = NULL;
 		INCR(dsp->dr_nlast);
 		mutex_exit(&dsp->dr_lock);
 		/*
 		 * Release dip on attach failure
 		 */
 		if (dip) {
 			ddi_release_devi(dip);
 		}
 		break;
 	default:
 		break;
 	}

 	putnext(q, mp);
 	return (0);
 }

 /*
  * Detect dl attach, hold the dip to prevent it from detaching
  */
 static int
 drwput(queue_t *q, mblk_t *mp)
 {
 	struct drstate *dsp;
 	union DL_primitives *dlp;
 	dev_info_t *dip;

 	switch (DB_TYPE(mp)) {
 	case M_PROTO:
 	case M_PCPROTO:
 		break;
 	default:
 		putnext(q, mp);
 		return (0);
 	}

 	/* make sure size is sufficient for dl_primitive */
 	if (MBLKL(mp) < sizeof (t_uscalar_t)) {
 		putnext(q, mp);
 		return (0);
 	}

 	dlp = (union DL_primitives *)mp->b_rptr;
 	switch (dlp->dl_primitive) {
 	case DL_ATTACH_REQ:
 		/*
 		 * Check for proper size of the message.
 		 *
 		 * If size is correct, get the ppa and attempt to
 		 * hold the device assuming ppa is instance.
 		 *
 		 * If size is wrong, we can't get the ppa, but
 		 * still increment dr_nfirst because the read side
 		 * will get a error ack on DL_ATTACH_REQ.
 		 */
 		dip = NULL;
 		dsp = q->q_ptr;
 		if (MBLKL(mp) >= DL_OK_ACK_SIZE) {
 			dip = ddi_hold_devi_by_instance(dsp->dr_major,
 			    dlp->attach_req.dl_ppa, E_DDI_HOLD_DEVI_NOATTACH);
 		}

 		mutex_enter(&dsp->dr_lock);
 		dsp->dr_dip[dsp->dr_nfirst] = dip;
 		INCR(dsp->dr_nfirst);
 		/*
 		 * Check if ring buffer is full. If so, assert in debug
 		 * kernel and produce a warning in non-debug kernel.
 		 */
 		ASSERT(dsp->dr_nfirst != dsp->dr_nlast);
 		if (dsp->dr_nfirst == dsp->dr_nlast) {
 			cmn_err(CE_WARN, "drcompat: internal buffer full");
 		}
 		mutex_exit(&dsp->dr_lock);
 		break;
 	default:
 		break;
 	}

 	putnext(q, mp);
 	return (0);
 }
	/*
	* 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.
	*/

	/*
	* Standard module for handling DLPI Style 2 attach/detach
	*/

	#include <sys/types.h>
	#include <sys/conf.h>
	#include <sys/modctl.h>
	#include <sys/cmn_err.h>
	#include <sys/sunddi.h>
	#include <sys/esunddi.h>
	#include <sys/strsubr.h>
	#include <sys/ddi.h>
	#include <sys/dlpi.h>
	#include <sys/strsun.h>
	#include <sys/policy.h>

	static struct streamtab drstab;

	static struct fmodsw fsw = {
	DRMODNAME,
	&drstab,
	D_MP
	};


	/*
	* Module linkage information for the kernel.
	*/

	static struct modlstrmod modlstrmod = {
	&mod_strmodops, "dr compatibility for DLPI style 2 drivers", &fsw
	};


	static struct modlinkage modlinkage = {
	MODREV_1, &modlstrmod, 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));
	}


	static int dropen(queue_t , dev_t , int, int, cred_t *);
	static int drclose(queue_t , int, cred_t );
	static int drrput(queue_t , mblk_t );
	static int drwput(queue_t , mblk_t );

	static struct module_info drinfo = {
	0,
	DRMODNAME,
	0,
	INFPSZ,
	1,
	0
	};

	static struct qinit drrinit = {
	(int (*)())drrput,
	NULL,
	dropen,
	drclose,
	NULL,
	&drinfo
	};

	static struct qinit drwinit = {
	(int (*)())drwput,
	NULL,
	NULL,
	NULL,
	NULL,
	&drinfo
	};

	static struct streamtab drstab = {
	&drrinit,
	&drwinit,
	NULL,
	NULL
	};

	/*
	* This module is pushed directly on top of the bottom driver
	* in a DLPI style-2 stream by stropen(). It intercepts
	* DL_ATTACH_REQ/DL_DETACH_REQ messages on the write side
	* and acks on the read side, calls qassociate where needed.
	* The primary purpose is to workaround a DR race condition
	* affecting non-DDI compliant DLPI style 2 drivers, which may
	* cause the system to panic.
	*
	* The following action is taken:
	* Write side (drwput):
	* attach request: hold driver instance assuming ppa == instance.
	* This way, the instance cannot be detached while the
	* driver is processing DL_ATTACH_REQ.
	*
	* On a successful hold, store the dip in a ring buffer
	* to be processed lated by the read side.
	* If hold fails (most likely ppa != instance), we store
	* NULL in the ring buffer and read side won't take
	* any action on ack.
	*
	* Read side (drrput):
	* attach success: if (dip held on write side) associate queue with dip
	* attach failure: if (dip held on write side) release hold on dip
	* detach success: associate queue with NULL
	* detach failure: do nothing
	*
	* The module assumes that incoming DL_ATTACH_REQ/DL_DETACH_REQ
	* messages are ordered (non-concurrent) and the bottom
	* driver processes them and sends acknowledgements in the same
	* order. This assumption is reasonable because concurrent
	* association results in non-deterministic queue behavior.
	* The module is coded carefully such that unordered messages
	* do not result in a system panic.
	*
	* The module handles multiple outstanding messages queued
	* in the bottom driver. Messages processed on the write side
	* but not yet arrived at read side are placed in the ring buffer
	* dr_dip[], between dr_nfirst and dr_nlast. The write side is
	* producer and the read side is the consumer. The buffer is full
	* when dr_nfirst == dr_nlast.
	*
	* The current size of the ring buffer is 64 (MAX_DLREQS) per stream.
	* During normal testing, we have not seen outstanding messages
	* above 10.
	*/

	#define MAX_DLREQS 64
	#define INCR(x) {(x)++; if ((x) >= MAX_DLREQS) (x) = 0; }

	struct drstate {
	kmutex_t dr_lock;
	major_t dr_major;
	int dr_nfirst;
	int dr_nlast;
	dev_info_t *dr_dip[MAX_DLREQS];
	};

	/* ARGSUSED1 */
	static int
	dropen(queue_t q, dev_t devp, int oflag, int sflag, cred_t *crp)
	{
	struct drstate *dsp;

	if (sflag != MODOPEN) { /* must be a pushed module */
	return (EINVAL);
	}

	if (secpolicy_net_rawaccess(crp) != 0) {
	return (EPERM);
	}

	if (q->q_ptr != NULL) {
	return (0); /* already open */
	}

	dsp = kmem_zalloc(sizeof (*dsp), KM_SLEEP);
	dsp->dr_major = getmajor(*devp);
	mutex_init(&dsp->dr_lock, NULL, MUTEX_DEFAULT, NULL);
	q->q_ptr = OTHERQ(q)->q_ptr = dsp;
	qprocson(q);
	ddi_assoc_queue_with_devi(q, NULL);
	return (0);
	}

	/* ARGSUSED1 */
	static int
	drclose(queue_t q, int cflag, cred_t crp)
	{
	struct drstate *dsp = q->q_ptr;

	ASSERT(dsp);
	ddi_assoc_queue_with_devi(q, NULL);
	qprocsoff(q);

	mutex_destroy(&dsp->dr_lock);
	kmem_free(dsp, sizeof (*dsp));
	q->q_ptr = NULL;

	return (0);
	}

	static int
	drrput(queue_t q, mblk_t mp)
	{
	struct drstate *dsp;
	union DL_primitives *dlp;
	dev_info_t *dip;

	switch (DB_TYPE(mp)) {
	case M_PROTO:
	case M_PCPROTO:
	break;
	default:
	putnext(q, mp);
	return (0);
	}

	/* make sure size is sufficient for dl_primitive */
	if (MBLKL(mp) < sizeof (t_uscalar_t)) {
	putnext(q, mp);
	return (0);
	}

	dlp = (union DL_primitives *)mp->b_rptr;
	switch (dlp->dl_primitive) {
	case DL_OK_ACK: {
	/* check for proper size, let upper layer deal with error */
	if (MBLKL(mp) < DL_OK_ACK_SIZE) {
	putnext(q, mp);
	return (0);
	}

	dsp = q->q_ptr;
	switch (dlp->ok_ack.dl_correct_primitive) {
	case DL_ATTACH_REQ:
	/*
	* ddi_assoc_queue_with_devi() will hold dip,
	* so release after association.
	*
	* dip is NULL means we didn't hold dip on read side.
	* (unlikely, but possible), so we do nothing.
	*/
	mutex_enter(&dsp->dr_lock);
	dip = dsp->dr_dip[dsp->dr_nlast];
	dsp->dr_dip[dsp->dr_nlast] = NULL;
	INCR(dsp->dr_nlast);
	mutex_exit(&dsp->dr_lock);
	if (dip) {
	ddi_assoc_queue_with_devi(q, dip);
	ddi_release_devi(dip);
	}
	break;

	case DL_DETACH_REQ:
	ddi_assoc_queue_with_devi(q, NULL);
	break;
	default:
	break;
	}
	break;
	}
	case DL_ERROR_ACK:
	if (dlp->error_ack.dl_error_primitive != DL_ATTACH_REQ)
	break;

	dsp = q->q_ptr;
	mutex_enter(&dsp->dr_lock);
	dip = dsp->dr_dip[dsp->dr_nlast];
	dsp->dr_dip[dsp->dr_nlast] = NULL;
	INCR(dsp->dr_nlast);
	mutex_exit(&dsp->dr_lock);
	/*
	* Release dip on attach failure
	*/
	if (dip) {
	ddi_release_devi(dip);
	}
	break;
	default:
	break;
	}

	putnext(q, mp);
	return (0);
	}

	/*
	* Detect dl attach, hold the dip to prevent it from detaching
	*/
	static int
	drwput(queue_t q, mblk_t mp)
	{
	struct drstate *dsp;
	union DL_primitives *dlp;
	dev_info_t *dip;

	switch (DB_TYPE(mp)) {
	case M_PROTO:
	case M_PCPROTO:
	break;
	default:
	putnext(q, mp);
	return (0);
	}

	/* make sure size is sufficient for dl_primitive */
	if (MBLKL(mp) < sizeof (t_uscalar_t)) {
	putnext(q, mp);
	return (0);
	}

	dlp = (union DL_primitives *)mp->b_rptr;
	switch (dlp->dl_primitive) {
	case DL_ATTACH_REQ:
	/*
	* Check for proper size of the message.
	*
	* If size is correct, get the ppa and attempt to
	* hold the device assuming ppa is instance.
	*
	* If size is wrong, we can't get the ppa, but
	* still increment dr_nfirst because the read side
	* will get a error ack on DL_ATTACH_REQ.
	*/
	dip = NULL;
	dsp = q->q_ptr;
	if (MBLKL(mp) >= DL_OK_ACK_SIZE) {
	dip = ddi_hold_devi_by_instance(dsp->dr_major,
	dlp->attach_req.dl_ppa, E_DDI_HOLD_DEVI_NOATTACH);
	}

	mutex_enter(&dsp->dr_lock);
	dsp->dr_dip[dsp->dr_nfirst] = dip;
	INCR(dsp->dr_nfirst);
	/*
	* Check if ring buffer is full. If so, assert in debug
	* kernel and produce a warning in non-debug kernel.
	*/
	ASSERT(dsp->dr_nfirst != dsp->dr_nlast);
	if (dsp->dr_nfirst == dsp->dr_nlast) {
	cmn_err(CE_WARN, "drcompat: internal buffer full");
	}
	mutex_exit(&dsp->dr_lock);
	break;
	default:
	break;
	}

	putnext(q, mp);
	return (0);
	}