usr/src/uts/common/io/drcompat.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.
 */

/*
 * 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);
}