xref: /onnv-gate/usr/src/uts/common/io/emul64_bsd.c (revision 85:1bca8d4eab66)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

/*
 * pseudo scsi disk driver
 */

#include <sys/scsi/scsi.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/kmem.h>
#include <sys/taskq.h>
#include <sys/disp.h>
#include <sys/types.h>
#include <sys/buf.h>

#include <sys/emul64.h>
#include <sys/emul64cmd.h>
#include <sys/emul64var.h>

/*
 * Mode sense/select page control
 */
#define	MODE_SENSE_PC_CURRENT		0
#define	MODE_SENSE_PC_CHANGEABLE	1
#define	MODE_SENSE_PC_DEFAULT		2
#define	MODE_SENSE_PC_SAVED		3

/*
 * Byte conversion macros
 */
#if	defined(_BIG_ENDIAN)
#define	ushort_to_scsi_ushort(n)	(n)
#define	uint32_to_scsi_uint32(n)	(n)
#define	uint64_to_scsi_uint64(n)	(n)
#elif	defined(_LITTLE_ENDIAN)

#define	ushort_to_scsi_ushort(n)			\
		((((n) & 0x00ff) << 8) |		\
		(((n)  & 0xff00) >> 8))

#define	uint32_to_scsi_uint32(n)			\
		((((n) & 0x000000ff) << 24) |		\
		(((n)  & 0x0000ff00) << 8) |		\
		(((n)  & 0x00ff0000) >> 8) |		\
		(((n)  & 0xff000000) >> 24))
#define	uint64_to_scsi_uint64(n)				\
		((((n) & 0x00000000000000ff) << 56) |           \
		(((n)  & 0x000000000000ff00) << 40) |           \
		(((n)  & 0x0000000000ff0000) << 24) |           \
		(((n)  & 0x00000000ff000000) << 8) |            \
		(((n)  & 0x000000ff00000000) >> 8) |            \
		(((n)  & 0x0000ff0000000000) >> 24) |           \
		(((n)  & 0x00ff000000000000) >> 40) |           \
		(((n)  & 0xff00000000000000) >> 56))
#else
error no _BIG_ENDIAN or _LITTLE_ENDIAN
#endif
#define	uint_to_byte0(n)		((n) & 0xff)
#define	uint_to_byte1(n)		(((n)>>8) & 0xff)
#define	uint_to_byte2(n)		(((n)>>16) & 0xff)
#define	uint_to_byte3(n)		(((n)>>24) & 0xff)

/*
 * struct prop_map
 *
 * This structure maps a property name to the place to store its value.
 */
struct prop_map {
	char 		*pm_name;	/* Name of the property. */
	int		*pm_value;	/* Place to store the value. */
};

static int emul64_debug_blklist = 0;

/*
 * Some interesting statistics.  These are protected by the
 * emul64_stats_mutex.  It would be nice to have an ioctl to print them out,
 * but we don't have the development time for that now.  You can at least
 * look at them with adb.
 */

int		emul64_collect_stats = 1; /* Collect stats if non-zero */
kmutex_t	emul64_stats_mutex;	/* Protect these variables */
long		emul64_nowrite_count = 0; /* # active nowrite ranges */
static uint64_t	emul64_skipped_io = 0;	/* Skipped I/O operations, because of */
					/* EMUL64_WRITE_OFF. */
static uint64_t	emul64_skipped_blk = 0;	/* Skipped blocks because of */
					/* EMUL64_WRITE_OFF. */
static uint64_t	emul64_io_ops = 0;	/* Total number of I/O operations */
					/* including skipped and actual. */
static uint64_t	emul64_io_blocks = 0;	/* Total number of blocks involved */
					/* in I/O operations. */
static uint64_t	emul64_nonzero = 0;	/* Number of non-zero data blocks */
					/* currently held in memory */
static uint64_t	emul64_max_list_length = 0; /* Maximum size of a linked */
					    /* list of non-zero blocks. */
uint64_t emul64_taskq_max = 0;		/* emul64_scsi_start uses the taskq */
					/* mechanism to dispatch work. */
					/* If the number of entries in the */
					/* exceeds the maximum for the queue */
					/* the queue a 1 second delay is */
					/* encountered in taskq_ent_alloc. */
					/* This counter counts the number */
					/* times that this happens. */

/*
 * Since emul64 does no physical I/O, operations that would normally be I/O
 * intensive become CPU bound.  An example of this is RAID 5
 * initialization.  When the kernel becomes CPU bound, it looks as if the
 * machine is hung.
 *
 * To avoid this problem, we provide a function, emul64_yield_check, that does a
 * delay from time to time to yield up the CPU.  The following variables
 * are tunables for this algorithm.
 *
 *	emul64_num_delay_called	Number of times we called delay.  This is
 *				not really a tunable.  Rather it is a
 *				counter that provides useful information
 *				for adjusting the tunables.
 *	emul64_yield_length	Number of microseconds to yield the CPU.
 *	emul64_yield_period	Number of I/O operations between yields.
 *	emul64_yield_enable	emul64 will yield the CPU, only if this
 *				variable contains a non-zero value.  This
 *				allows the yield functionality to be turned
 *				off for experimentation purposes.
 *
 * The value of 1000 for emul64_yield_period has been determined by
 * experience with running the tests.
 */
static uint64_t		emul64_num_delay_called = 0;
static int		emul64_yield_length = 1000;
static int		emul64_yield_period = 1000;
static int		emul64_yield_enable = 1;
static kmutex_t		emul64_yield_mutex;
static kcondvar_t 	emul64_yield_cv;

/*
 * This array establishes a set of tunable variables that can be set by
 * defining properties in the emul64.conf file.
 */
struct prop_map emul64_properties[] = {
	"emul64_collect_stats",		&emul64_collect_stats,
	"emul64_yield_length",		&emul64_yield_length,
	"emul64_yield_period",		&emul64_yield_period,
	"emul64_yield_enable",		&emul64_yield_enable,
	"emul64_max_task",		&emul64_max_task,
	"emul64_task_nthreads",		&emul64_task_nthreads
};

static unsigned char *emul64_zeros = NULL; /* Block of 0s for comparison */

extern void emul64_check_cond(struct scsi_pkt *pkt, uchar_t key,
				uchar_t asc, uchar_t ascq);
/* ncyl=250000 acyl=2 nhead=24 nsect=357 */
uint_t dkg_rpm = 3600;

static int bsd_mode_sense_dad_mode_geometry(struct scsi_pkt *);
static int bsd_mode_sense_dad_mode_err_recov(struct scsi_pkt *);
static int bsd_mode_sense_modepage_disco_reco(struct scsi_pkt *);
static int bsd_mode_sense_dad_mode_format(struct scsi_pkt *);
static int bsd_mode_sense_dad_mode_cache(struct scsi_pkt *);
static int bsd_readblks(struct emul64 *, ushort_t, ushort_t, diskaddr_t,
				int, unsigned char *);
static int bsd_writeblks(struct emul64 *, ushort_t, ushort_t, diskaddr_t,
				int, unsigned char *);
emul64_tgt_t *find_tgt(struct emul64 *, ushort_t, ushort_t);
static blklist_t *bsd_findblk(emul64_tgt_t *, diskaddr_t, avl_index_t *);
static void bsd_allocblk(emul64_tgt_t *, diskaddr_t, caddr_t, avl_index_t);
static void bsd_freeblk(emul64_tgt_t *, blklist_t *);
static void emul64_yield_check();
static emul64_rng_overlap_t bsd_tgt_overlap(emul64_tgt_t *, diskaddr_t, int);

char *emul64_name = "emul64";


/* XXX replace with FORMG0COUNT */
#define	GETG0COUNT(cdb)		((cdb)->g0_count0)

#define	GETG1COUNT(cdb)		((cdb)->g1_count1 << 8)  + \
				((cdb)->g1_count0)

#define	GETG4COUNT(cdb)	\
			((uint64_t)(cdb)->g4_count3 << 24)  + \
			((uint64_t)(cdb)->g4_count2 << 16)  + \
			((uint64_t)(cdb)->g4_count1 << 8)  + \
			((uint64_t)(cdb)->g4_count0)


/*
 * Initialize globals in this file.
 */
void
emul64_bsd_init()
{
	emul64_zeros = (unsigned char *) kmem_zalloc(DEV_BSIZE, KM_SLEEP);
	mutex_init(&emul64_stats_mutex, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&emul64_yield_mutex, NULL, MUTEX_DRIVER, NULL);
	cv_init(&emul64_yield_cv, NULL, CV_DRIVER, NULL);
}

/*
 * Clean up globals in this file.
 */
void
emul64_bsd_fini()
{
	cv_destroy(&emul64_yield_cv);
	mutex_destroy(&emul64_yield_mutex);
	mutex_destroy(&emul64_stats_mutex);
	if (emul64_zeros != NULL) {
		kmem_free(emul64_zeros, DEV_BSIZE);
		emul64_zeros = NULL;
	}
}

/*
 * Attempt to get the values of the properties that are specified in the
 * emul64_properties array.  If the property exists, copy its value to the
 * specified location.  All the properties have been assigned default
 * values in this driver, so if we cannot get the property that is not a
 * problem.
 */
void
emul64_bsd_get_props(dev_info_t *dip)
{
	uint_t		count;
	uint_t		i;
	struct prop_map	*pmp;
	int		*properties;

	for (pmp = emul64_properties, i = 0;
		i < sizeof (emul64_properties) / sizeof (struct prop_map);
		i++, pmp++) {
		if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip,
				DDI_PROP_DONTPASS,
				pmp->pm_name, &properties,
				&count) == DDI_PROP_SUCCESS) {
			if (count >= 1) {
				*pmp->pm_value = *properties;
			}
			ddi_prop_free((void *) properties);
		}
	}
}

int
emul64_bsd_blkcompare(const void *a1, const void *b1)
{
	blklist_t	*a = (blklist_t *)a1;
	blklist_t	*b = (blklist_t *)b1;

	if (a->bl_blkno < b->bl_blkno)
		return (-1);
	if (a->bl_blkno == b->bl_blkno)
		return (0);
	return (1);
}

/* ARGSUSED 0 */
int
bsd_scsi_start_stop_unit(struct scsi_pkt *pkt)
{
	return (0);
}

/* ARGSUSED 0 */
int
bsd_scsi_test_unit_ready(struct scsi_pkt *pkt)
{
	return (0);
}

/* ARGSUSED 0 */
int
bsd_scsi_request_sense(struct scsi_pkt *pkt)
{
	return (0);
}

int
bsd_scsi_inq_page0(struct scsi_pkt *pkt, uchar_t pqdtype)
{
	struct emul64_cmd	*sp = PKT2CMD(pkt);

	if (sp->cmd_count < 6) {
		cmn_err(CE_CONT, "%s: bsd_scsi_inq_page0: size %d required\n",
		    emul64_name, 6);
		return (EIO);
	}

	sp->cmd_addr[0] = pqdtype;	/* periph qual., dtype */
	sp->cmd_addr[1] = 0;		/* page code */
	sp->cmd_addr[2] = 0;		/* reserved */
	sp->cmd_addr[3] = 6 - 3;	/* length */
	sp->cmd_addr[4] = 0;		/* 1st page */
	sp->cmd_addr[5] = 0x83;		/* 2nd page */

	pkt->pkt_resid = sp->cmd_count - 6;
	return (0);
}

int
bsd_scsi_inq_page83(struct scsi_pkt *pkt, uchar_t pqdtype)
{
	struct emul64		*emul64 = PKT2EMUL64(pkt);
	struct emul64_cmd	*sp = PKT2CMD(pkt);
	int			instance = ddi_get_instance(emul64->emul64_dip);

	if (sp->cmd_count < 22) {
		cmn_err(CE_CONT, "%s: bsd_scsi_inq_page83: size %d required\n",
		    emul64_name, 22);
		return (EIO);
	}

	sp->cmd_addr[0] = pqdtype;	/* periph qual., dtype */
	sp->cmd_addr[1] = 0x83;		/* page code */
	sp->cmd_addr[2] = 0;		/* reserved */
	sp->cmd_addr[3] = (22 - 8) + 4;	/* length */

	sp->cmd_addr[4] = 1;		/* code set - binary */
	sp->cmd_addr[5] = 3;		/* association and device ID type 3 */
	sp->cmd_addr[6] = 0;		/* reserved */
	sp->cmd_addr[7] = 22 - 8;	/* ID length */

	sp->cmd_addr[8] = 0xde;		/* @8: identifier, byte 0 */
	sp->cmd_addr[9] = 0xca;
	sp->cmd_addr[10] = 0xde;
	sp->cmd_addr[11] = 0x80;

	sp->cmd_addr[12] = 0xba;
	sp->cmd_addr[13] = 0xbe;
	sp->cmd_addr[14] = 0xab;
	sp->cmd_addr[15] = 0xba;
					/* @22: */

	/*
	 * Instances seem to be assigned sequentially, so it unlikely that we
	 * will have more than 65535 of them.
	 */
	sp->cmd_addr[16] = uint_to_byte1(instance);
	sp->cmd_addr[17] = uint_to_byte0(instance);
	sp->cmd_addr[18] = uint_to_byte1(TGT(sp));
	sp->cmd_addr[19] = uint_to_byte0(TGT(sp));
	sp->cmd_addr[20] = uint_to_byte1(LUN(sp));
	sp->cmd_addr[21] = uint_to_byte0(LUN(sp));

	pkt->pkt_resid = sp->cmd_count - 22;
	return (0);
}

int
bsd_scsi_inquiry(struct scsi_pkt *pkt)
{
	struct emul64_cmd	*sp = PKT2CMD(pkt);
	union scsi_cdb		*cdb = (union scsi_cdb *)pkt->pkt_cdbp;
	emul64_tgt_t		*tgt;
	uchar_t			pqdtype;
	struct scsi_inquiry	inq;

	EMUL64_MUTEX_ENTER(sp->cmd_emul64);
	tgt = find_tgt(sp->cmd_emul64,
	    pkt->pkt_address.a_target, pkt->pkt_address.a_lun);
	EMUL64_MUTEX_EXIT(sp->cmd_emul64);

	if (sp->cmd_count < sizeof (inq)) {
		cmn_err(CE_CONT, "%s: bsd_scsi_inquiry: size %d required\n",
		    emul64_name, (int)sizeof (inq));
		return (EIO);
	}

	if (cdb->cdb_opaque[1] & 0xfc) {
		cmn_err(CE_WARN, "%s: bsd_scsi_inquiry: 0x%x",
		    emul64_name, cdb->cdb_opaque[1]);
		emul64_check_cond(pkt, 0x5, 0x24, 0x0);	/* inv. fld in cdb */
		return (0);
	}

	pqdtype = tgt->emul64_tgt_dtype;
	if (cdb->cdb_opaque[1] & 0x1) {
		switch (cdb->cdb_opaque[2]) {
			case 0x00:
				return (bsd_scsi_inq_page0(pkt, pqdtype));
			case 0x83:
				return (bsd_scsi_inq_page83(pkt, pqdtype));
			default:
				cmn_err(CE_WARN, "%s: bsd_scsi_inquiry: "
				    "unsupported 0x%x",
				    emul64_name, cdb->cdb_opaque[2]);
				return (0);
		}
	}

	/* set up the inquiry data we return */
	(void) bzero((void *)&inq, sizeof (inq));

	inq.inq_dtype = pqdtype;
	inq.inq_ansi = 2;
	inq.inq_rdf = 2;
	inq.inq_len = sizeof (inq) - 4;
	inq.inq_wbus16 = 1;
	inq.inq_cmdque = 1;

	(void) bcopy(tgt->emul64_tgt_inq, inq.inq_vid,
	    sizeof (tgt->emul64_tgt_inq));
	(void) bcopy("1", inq.inq_revision, 2);
	(void) bcopy((void *)&inq, sp->cmd_addr, sizeof (inq));

	pkt->pkt_resid = sp->cmd_count - sizeof (inq);
	return (0);
}

/* ARGSUSED 0 */
int
bsd_scsi_format(struct scsi_pkt *pkt)
{
	return (0);
}

int
bsd_scsi_io(struct scsi_pkt *pkt)
{
	struct emul64_cmd	*sp = PKT2CMD(pkt);
	union scsi_cdb		*cdb = (union scsi_cdb *)pkt->pkt_cdbp;
	diskaddr_t		lblkno;
	int			nblks;

	switch (cdb->scc_cmd) {
	case SCMD_READ:
			lblkno = (uint32_t)GETG0ADDR(cdb);
			nblks = GETG0COUNT(cdb);
			pkt->pkt_resid = bsd_readblks(sp->cmd_emul64,
					pkt->pkt_address.a_target,
					pkt->pkt_address.a_lun,
					lblkno, nblks, sp->cmd_addr);
			if (emul64debug) {
				cmn_err(CE_CONT, "%s: bsd_scsi_io: "
				    "read g0 blk=%lld (0x%llx) nblks=%d\n",
				    emul64_name, lblkno, lblkno, nblks);
			}
		break;
	case SCMD_WRITE:
			lblkno = (uint32_t)GETG0ADDR(cdb);
			nblks = GETG0COUNT(cdb);
			pkt->pkt_resid = bsd_writeblks(sp->cmd_emul64,
					pkt->pkt_address.a_target,
					pkt->pkt_address.a_lun,
					lblkno, nblks, sp->cmd_addr);
			if (emul64debug) {
				cmn_err(CE_CONT, "%s: bsd_scsi_io: "
				    "write g0 blk=%lld (0x%llx) nblks=%d\n",
				    emul64_name, lblkno, lblkno, nblks);
			}
		break;
	case SCMD_READ_G1:
			lblkno = (uint32_t)GETG1ADDR(cdb);
			nblks = GETG1COUNT(cdb);
			pkt->pkt_resid = bsd_readblks(sp->cmd_emul64,
					pkt->pkt_address.a_target,
					pkt->pkt_address.a_lun,
					lblkno, nblks, sp->cmd_addr);
			if (emul64debug) {
				cmn_err(CE_CONT, "%s: bsd_scsi_io: "
				    "read g1 blk=%lld (0x%llx) nblks=%d\n",
				    emul64_name, lblkno, lblkno, nblks);
			}
		break;
	case SCMD_WRITE_G1:
			lblkno = (uint32_t)GETG1ADDR(cdb);
			nblks = GETG1COUNT(cdb);
			pkt->pkt_resid = bsd_writeblks(sp->cmd_emul64,
					pkt->pkt_address.a_target,
					pkt->pkt_address.a_lun,
					lblkno, nblks, sp->cmd_addr);
			if (emul64debug) {
				cmn_err(CE_CONT, "%s: bsd_scsi_io: "
				    "write g1 blk=%lld (0x%llx) nblks=%d\n",
				    emul64_name, lblkno, lblkno, nblks);
			}
		break;
	case SCMD_READ_G4:
			lblkno = GETG4ADDR(cdb);
			lblkno <<= 32;
			lblkno |= (uint32_t)GETG4ADDRTL(cdb);
			nblks = GETG4COUNT(cdb);
			pkt->pkt_resid = bsd_readblks(sp->cmd_emul64,
					pkt->pkt_address.a_target,
					pkt->pkt_address.a_lun,
					lblkno, nblks, sp->cmd_addr);
			if (emul64debug) {
				cmn_err(CE_CONT, "%s: bsd_scsi_io: "
				    "read g4 blk=%lld (0x%llx) nblks=%d\n",
				    emul64_name, lblkno, lblkno, nblks);
			}
		break;
	case SCMD_WRITE_G4:
			lblkno = GETG4ADDR(cdb);
			lblkno <<= 32;
			lblkno |= (uint32_t)GETG4ADDRTL(cdb);
			nblks = GETG4COUNT(cdb);
			pkt->pkt_resid = bsd_writeblks(sp->cmd_emul64,
					pkt->pkt_address.a_target,
					pkt->pkt_address.a_lun,
					lblkno, nblks, sp->cmd_addr);
			if (emul64debug) {
				cmn_err(CE_CONT, "%s: bsd_scsi_io: "
				    "write g4 blk=%lld (0x%llx) nblks=%d\n",
				    emul64_name, lblkno, lblkno, nblks);
			}
		break;
	default:
		cmn_err(CE_WARN, "%s: bsd_scsi_io: unhandled I/O: 0x%x",
		    emul64_name, cdb->scc_cmd);
		break;
	}

	if (pkt->pkt_resid != 0)
		cmn_err(CE_WARN, "%s: bsd_scsi_io: "
		    "pkt_resid: 0x%lx, lblkno %lld, nblks %d",
		    emul64_name, pkt->pkt_resid, lblkno, nblks);

	return (0);
}

int
bsd_scsi_log_sense(struct scsi_pkt *pkt)
{
	union scsi_cdb		*cdb = (union scsi_cdb *)pkt->pkt_cdbp;
	struct emul64_cmd	*sp = PKT2CMD(pkt);
	int			page_code;

	if (sp->cmd_count < 9) {
		cmn_err(CE_CONT, "%s: bsd_scsi_log_sense size %d required\n",
		    emul64_name, 9);
		return (EIO);
	}

	page_code = cdb->cdb_opaque[2] & 0x3f;
	if (page_code) {
		cmn_err(CE_CONT, "%s: bsd_scsi_log_sense: "
		    "page 0x%x not supported\n", emul64_name, page_code);
		emul64_check_cond(pkt, 0x5, 0x24, 0x0); /* inv. fld in cdb */
		return (0);
	}

	sp->cmd_addr[0] = 0;		/* page code */
	sp->cmd_addr[1] = 0;		/* reserved */
	sp->cmd_addr[2] = 0;		/* MSB of page length */
	sp->cmd_addr[3] = 8 - 3;	/* LSB of page length */

	sp->cmd_addr[4] = 0;		/* MSB of parameter code */
	sp->cmd_addr[5] = 0;		/* LSB of parameter code */
	sp->cmd_addr[6] = 0;		/* parameter control byte */
	sp->cmd_addr[7] = 4 - 3;	/* parameter length */
	sp->cmd_addr[8] = 0x0;		/* parameter value */

	pkt->pkt_resid = sp->cmd_count - 9;
	return (0);
}

int
bsd_scsi_mode_sense(struct scsi_pkt *pkt)
{
	union scsi_cdb	*cdb = (union scsi_cdb *)pkt->pkt_cdbp;
	int		page_control;
	int		page_code;
	int		rval = 0;

	switch (cdb->scc_cmd) {
	case SCMD_MODE_SENSE:
			page_code = cdb->cdb_opaque[2] & 0x3f;
			page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;
			if (emul64debug) {
				cmn_err(CE_CONT, "%s: bsd_scsi_mode_sense: "
				    "page=0x%x control=0x%x nbytes=%d\n",
				    emul64_name, page_code, page_control,
				    GETG0COUNT(cdb));
			}
		break;
	case SCMD_MODE_SENSE_G1:
			page_code = cdb->cdb_opaque[2] & 0x3f;
			page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;
			if (emul64debug) {
				cmn_err(CE_CONT, "%s: bsd_scsi_mode_sense: "
				    "page=0x%x control=0x%x nbytes=%d\n",
				    emul64_name, page_code, page_control,
				    GETG1COUNT(cdb));
			}
		break;
	default:
		cmn_err(CE_CONT, "%s: bsd_scsi_mode_sense: "
		    "cmd 0x%x not supported\n", emul64_name, cdb->scc_cmd);
		return (EIO);
	}

	switch (page_code) {
	case DAD_MODE_GEOMETRY:
		rval = bsd_mode_sense_dad_mode_geometry(pkt);
		break;
	case DAD_MODE_ERR_RECOV:
		rval = bsd_mode_sense_dad_mode_err_recov(pkt);
		break;
	case MODEPAGE_DISCO_RECO:
		rval = bsd_mode_sense_modepage_disco_reco(pkt);
		break;
	case DAD_MODE_FORMAT:
		rval = bsd_mode_sense_dad_mode_format(pkt);
		break;
	case DAD_MODE_CACHE:
		rval = bsd_mode_sense_dad_mode_cache(pkt);
		break;
	default:
		cmn_err(CE_CONT, "%s: bsd_scsi_mode_sense: "
		    "page 0x%x not supported\n", emul64_name, page_code);
		rval = EIO;
		break;
	}

	return (rval);
}


static int
bsd_mode_sense_dad_mode_geometry(struct scsi_pkt *pkt)
{
	struct emul64_cmd	*sp = PKT2CMD(pkt);
	union scsi_cdb		*cdb = (union scsi_cdb *)pkt->pkt_cdbp;
	uchar_t			*addr = (uchar_t *)sp->cmd_addr;
	emul64_tgt_t		*tgt;
	int			page_control;
	struct mode_header	header;
	struct mode_geometry	page4;
	int			ncyl;
	int			rval = 0;

	page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;

	if (emul64debug) {
		cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_geometry: "
		    "pc=%d n=%d\n", emul64_name, page_control, sp->cmd_count);
	}

	if (sp->cmd_count < (sizeof (header) + sizeof (page4))) {
		cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_geometry: "
		    "size %d required\n",
		    emul64_name, (int)(sizeof (header) + sizeof (page4)));
		return (EIO);
	}

	(void) bzero(&header, sizeof (header));
	(void) bzero(&page4, sizeof (page4));

	header.length = sizeof (header) + sizeof (page4) - 1;
	header.bdesc_length = 0;

	page4.mode_page.code = DAD_MODE_GEOMETRY;
	page4.mode_page.ps = 1;
	page4.mode_page.length = sizeof (page4) - sizeof (struct mode_page);

	switch (page_control) {
	case MODE_SENSE_PC_CURRENT:
	case MODE_SENSE_PC_DEFAULT:
	case MODE_SENSE_PC_SAVED:
		EMUL64_MUTEX_ENTER(sp->cmd_emul64);
		tgt = find_tgt(sp->cmd_emul64,
		    pkt->pkt_address.a_target, pkt->pkt_address.a_lun);
		EMUL64_MUTEX_EXIT(sp->cmd_emul64);
		ncyl = tgt->emul64_tgt_ncyls;
		page4.cyl_ub = uint_to_byte2(ncyl);
		page4.cyl_mb = uint_to_byte1(ncyl);
		page4.cyl_lb = uint_to_byte0(ncyl);
		page4.heads = uint_to_byte0(tgt->emul64_tgt_nheads);
		page4.rpm = ushort_to_scsi_ushort(dkg_rpm);
		break;
	case MODE_SENSE_PC_CHANGEABLE:
		page4.cyl_ub = 0xff;
		page4.cyl_mb = 0xff;
		page4.cyl_lb = 0xff;
		page4.heads = 0xff;
		page4.rpm = 0xffff;
		break;
	}

	(void) bcopy(&header, addr, sizeof (header));
	(void) bcopy(&page4, addr + sizeof (header), sizeof (page4));

	pkt->pkt_resid = sp->cmd_count - sizeof (page4) - sizeof (header);
	rval = 0;

	return (rval);
}

static int
bsd_mode_sense_dad_mode_err_recov(struct scsi_pkt *pkt)
{
	struct emul64_cmd	*sp = PKT2CMD(pkt);
	union scsi_cdb		*cdb = (union scsi_cdb *)pkt->pkt_cdbp;
	uchar_t			*addr = (uchar_t *)sp->cmd_addr;
	int			page_control;
	struct mode_header	header;
	struct mode_err_recov	page1;
	int			rval = 0;

	page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;

	if (emul64debug) {
		cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_err_recov: "
		    "pc=%d n=%d\n", emul64_name, page_control, sp->cmd_count);
	}

	if (sp->cmd_count < (sizeof (header) + sizeof (page1))) {
		cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_err_recov: "
		    "size %d required\n",
		    emul64_name, (int)(sizeof (header) + sizeof (page1)));
		return (EIO);
	}

	(void) bzero(&header, sizeof (header));
	(void) bzero(&page1, sizeof (page1));

	header.length = sizeof (header) + sizeof (page1) - 1;
	header.bdesc_length = 0;

	page1.mode_page.code = DAD_MODE_ERR_RECOV;
	page1.mode_page.ps = 1;
	page1.mode_page.length = sizeof (page1) - sizeof (struct mode_page);

	switch (page_control) {
	case MODE_SENSE_PC_CURRENT:
	case MODE_SENSE_PC_DEFAULT:
	case MODE_SENSE_PC_SAVED:
		break;
	case MODE_SENSE_PC_CHANGEABLE:
		break;
	}

	(void) bcopy(&header, addr, sizeof (header));
	(void) bcopy(&page1, addr + sizeof (header), sizeof (page1));

	pkt->pkt_resid = sp->cmd_count - sizeof (page1) - sizeof (header);
	rval = 0;

	return (rval);
}

static int
bsd_mode_sense_modepage_disco_reco(struct scsi_pkt *pkt)
{
	struct emul64_cmd	*sp = PKT2CMD(pkt);
	union scsi_cdb		*cdb = (union scsi_cdb *)pkt->pkt_cdbp;
	int			rval = 0;
	uchar_t			*addr = (uchar_t *)sp->cmd_addr;
	int			page_control;
	struct mode_header	header;
	struct mode_disco_reco	page2;

	page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;

	if (emul64debug) {
		cmn_err(CE_CONT, "%s: bsd_mode_sense_modepage_disco_reco: "
		    "pc=%d n=%d\n", emul64_name, page_control, sp->cmd_count);
	}

	if (sp->cmd_count < (sizeof (header) + sizeof (page2))) {
		cmn_err(CE_CONT, "%s: bsd_mode_sense_modepage_disco_reco: "
		    "size %d required\n",
		    emul64_name, (int)(sizeof (header) + sizeof (page2)));
		return (EIO);
	}

	(void) bzero(&header, sizeof (header));
	(void) bzero(&page2, sizeof (page2));

	header.length = sizeof (header) + sizeof (page2) - 1;
	header.bdesc_length = 0;

	page2.mode_page.code = MODEPAGE_DISCO_RECO;
	page2.mode_page.ps = 1;
	page2.mode_page.length = sizeof (page2) - sizeof (struct mode_page);

	switch (page_control) {
	case MODE_SENSE_PC_CURRENT:
	case MODE_SENSE_PC_DEFAULT:
	case MODE_SENSE_PC_SAVED:
		break;
	case MODE_SENSE_PC_CHANGEABLE:
		break;
	}

	(void) bcopy(&header, addr, sizeof (header));
	(void) bcopy(&page2, addr + sizeof (header), sizeof (page2));

	pkt->pkt_resid = sp->cmd_count - sizeof (page2) - sizeof (header);
	rval = 0;

	return (rval);
}

static int
bsd_mode_sense_dad_mode_format(struct scsi_pkt *pkt)
{
	struct emul64_cmd	*sp = PKT2CMD(pkt);
	union scsi_cdb		*cdb = (union scsi_cdb *)pkt->pkt_cdbp;
	uchar_t			*addr = (uchar_t *)sp->cmd_addr;
	emul64_tgt_t		*tgt;
	int			page_control;
	struct mode_header	header;
	struct mode_format	page3;
	int			rval = 0;

	page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;

	if (emul64debug) {
		cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_format: "
		    "pc=%d n=%d\n", emul64_name, page_control, sp->cmd_count);
	}

	if (sp->cmd_count < (sizeof (header) + sizeof (page3))) {
		cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_format: "
		    "size %d required\n",
		    emul64_name, (int)(sizeof (header) + sizeof (page3)));
		return (EIO);
	}

	(void) bzero(&header, sizeof (header));
	(void) bzero(&page3, sizeof (page3));

	header.length = sizeof (header) + sizeof (page3) - 1;
	header.bdesc_length = 0;

	page3.mode_page.code = DAD_MODE_FORMAT;
	page3.mode_page.ps = 1;
	page3.mode_page.length = sizeof (page3) - sizeof (struct mode_page);

	switch (page_control) {
	case MODE_SENSE_PC_CURRENT:
	case MODE_SENSE_PC_DEFAULT:
	case MODE_SENSE_PC_SAVED:
		page3.data_bytes_sect = ushort_to_scsi_ushort(DEV_BSIZE);
		page3.interleave = ushort_to_scsi_ushort(1);
		EMUL64_MUTEX_ENTER(sp->cmd_emul64);
		tgt = find_tgt(sp->cmd_emul64,
			pkt->pkt_address.a_target, pkt->pkt_address.a_lun);
		EMUL64_MUTEX_EXIT(sp->cmd_emul64);
		page3.sect_track = ushort_to_scsi_ushort(tgt->emul64_tgt_nsect);
		break;
	case MODE_SENSE_PC_CHANGEABLE:
		break;
	}

	(void) bcopy(&header, addr, sizeof (header));
	(void) bcopy(&page3, addr + sizeof (header), sizeof (page3));

	pkt->pkt_resid = sp->cmd_count - sizeof (page3) - sizeof (header);
	rval = 0;

	return (rval);
}

static int
bsd_mode_sense_dad_mode_cache(struct scsi_pkt *pkt)
{
	struct emul64_cmd	*sp = PKT2CMD(pkt);
	union scsi_cdb		*cdb = (union scsi_cdb *)pkt->pkt_cdbp;
	uchar_t			*addr = (uchar_t *)sp->cmd_addr;
	int			page_control;
	struct mode_header	header;
	struct mode_cache	page8;
	int			rval = 0;

	page_control = (cdb->cdb_opaque[2] >> 6) & 0x03;

	if (emul64debug) {
		cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_cache: "
		    "pc=%d n=%d\n", emul64_name, page_control, sp->cmd_count);
	}

	if (sp->cmd_count < (sizeof (header) + sizeof (page8))) {
		cmn_err(CE_CONT, "%s: bsd_mode_sense_dad_mode_cache: "
		    "size %d required\n",
		    emul64_name, (int)(sizeof (header) + sizeof (page8)));
		return (EIO);
	}

	(void) bzero(&header, sizeof (header));
	(void) bzero(&page8, sizeof (page8));

	header.length = sizeof (header) + sizeof (page8) - 1;
	header.bdesc_length = 0;

	page8.mode_page.code = DAD_MODE_CACHE;
	page8.mode_page.ps = 1;
	page8.mode_page.length = sizeof (page8) - sizeof (struct mode_page);

	switch (page_control) {
	case MODE_SENSE_PC_CURRENT:
	case MODE_SENSE_PC_DEFAULT:
	case MODE_SENSE_PC_SAVED:
		break;
	case MODE_SENSE_PC_CHANGEABLE:
		break;
	}

	(void) bcopy(&header, addr, sizeof (header));
	(void) bcopy(&page8, addr + sizeof (header), sizeof (page8));

	pkt->pkt_resid = sp->cmd_count - sizeof (page8) - sizeof (header);
	rval = 0;

	return (rval);
}

/* ARGSUSED 0 */
int
bsd_scsi_mode_select(struct scsi_pkt *pkt)
{
	return (0);
}

int
bsd_scsi_read_capacity_8(struct scsi_pkt *pkt)
{
	struct emul64_cmd	*sp = PKT2CMD(pkt);
	emul64_tgt_t		*tgt;
	struct scsi_capacity	cap;
	int			rval = 0;

	EMUL64_MUTEX_ENTER(sp->cmd_emul64);
	tgt = find_tgt(sp->cmd_emul64,
		pkt->pkt_address.a_target, pkt->pkt_address.a_lun);
	EMUL64_MUTEX_EXIT(sp->cmd_emul64);
	if (tgt->emul64_tgt_sectors > 0xffffffff)
		cap.capacity = 0xffffffff;
	else
		cap.capacity =
		    uint32_to_scsi_uint32(tgt->emul64_tgt_sectors);
	cap.lbasize = uint32_to_scsi_uint32((uint_t)DEV_BSIZE);

	pkt->pkt_resid = sp->cmd_count - sizeof (struct scsi_capacity);

	(void) bcopy(&cap, (caddr_t)sp->cmd_addr,
		    sizeof (struct scsi_capacity));
	return (rval);
}

int
bsd_scsi_read_capacity_16(struct scsi_pkt *pkt)
{
	struct emul64_cmd	*sp = PKT2CMD(pkt);
	emul64_tgt_t		*tgt;
	struct scsi_capacity_16 cap;
	int			rval = 0;

	EMUL64_MUTEX_ENTER(sp->cmd_emul64);
	tgt = find_tgt(sp->cmd_emul64,
		pkt->pkt_address.a_target, pkt->pkt_address.a_lun);
	EMUL64_MUTEX_EXIT(sp->cmd_emul64);

	cap.sc_capacity = uint64_to_scsi_uint64(tgt->emul64_tgt_sectors);
	cap.sc_lbasize = uint32_to_scsi_uint32((uint_t)DEV_BSIZE);
	cap.sc_rto_en = 0;
	cap.sc_prot_en = 0;
	cap.sc_rsvd0 = 0;
	bzero(&cap.sc_rsvd1[0], sizeof (cap.sc_rsvd1));

	pkt->pkt_resid = sp->cmd_count - sizeof (struct scsi_capacity_16);

	(void) bcopy(&cap, (caddr_t)sp->cmd_addr,
			sizeof (struct scsi_capacity_16));
	return (rval);
}
int
bsd_scsi_read_capacity(struct scsi_pkt *pkt)
{
	return (bsd_scsi_read_capacity_8(pkt));
}


/* ARGSUSED 0 */
int
bsd_scsi_reserve(struct scsi_pkt *pkt)
{
	return (0);
}

/* ARGSUSED 0 */
int
bsd_scsi_release(struct scsi_pkt *pkt)
{
	return (0);
}


int
bsd_scsi_read_defect_list(struct scsi_pkt *pkt)
{
	pkt->pkt_resid = 0;
	return (0);
}


/* ARGSUSED 0 */
int
bsd_scsi_reassign_block(struct scsi_pkt *pkt)
{
	return (0);
}


static int
bsd_readblks(struct emul64 *emul64, ushort_t a_target, ushort_t a_lun,
		diskaddr_t blkno, int nblks, unsigned char *bufaddr)
{
	emul64_tgt_t	*tgt;
	blklist_t	*blk;
	emul64_rng_overlap_t overlap;
	int		i = 0;

	if (emul64debug) {
		cmn_err(CE_CONT, "%s: bsd_readblks: "
		    "<%d,%d> blk %llu (0x%llx) nblks %d\n",
		    emul64_name, a_target, a_lun, blkno, blkno, nblks);
	}

	emul64_yield_check();

	EMUL64_MUTEX_ENTER(emul64);
	tgt = find_tgt(emul64, a_target, a_lun);
	EMUL64_MUTEX_EXIT(emul64);
	if (tgt == NULL) {
		cmn_err(CE_WARN, "%s: bsd_readblks: no target for %d,%d\n",
		    emul64_name, a_target, a_lun);
		goto unlocked_out;
	}

	if (emul64_collect_stats) {
		mutex_enter(&emul64_stats_mutex);
		emul64_io_ops++;
		emul64_io_blocks += nblks;
		mutex_exit(&emul64_stats_mutex);
	}
	mutex_enter(&tgt->emul64_tgt_blk_lock);

	/*
	 * Keep the ioctls from changing the nowrite list for the duration
	 * of this I/O by grabbing emul64_tgt_nw_lock.  This will keep the
	 * results from our call to bsd_tgt_overlap from changing while we
	 * do the I/O.
	 */
	rw_enter(&tgt->emul64_tgt_nw_lock, RW_READER);

	overlap = bsd_tgt_overlap(tgt, blkno, nblks);
	switch (overlap) {
	case O_SAME:
	case O_SUBSET:
	case O_OVERLAP:
		cmn_err(CE_WARN, "%s: bsd_readblks: "
		    "read to blocked area %lld,%d\n",
		    emul64_name, blkno, nblks);
		rw_exit(&tgt->emul64_tgt_nw_lock);
		goto errout;
	case O_NONE:
		break;
	}
	for (i = 0; i < nblks; i++) {
		if (emul64_debug_blklist)
			cmn_err(CE_CONT, "%s: bsd_readblks: "
			    "%d of %d: blkno %lld\n",
			    emul64_name, i+1, nblks, blkno);
		if (blkno > tgt->emul64_tgt_sectors)
			break;
		blk = bsd_findblk(tgt, blkno, NULL);
		if (blk) {
			(void) bcopy(blk->bl_data, bufaddr, DEV_BSIZE);
		} else {
			(void) bzero(bufaddr, DEV_BSIZE);
		}
		blkno++;
		bufaddr += DEV_BSIZE;
	}
	rw_exit(&tgt->emul64_tgt_nw_lock);

errout:
	mutex_exit(&tgt->emul64_tgt_blk_lock);

unlocked_out:
	return ((nblks - i) * DEV_BSIZE);
}


static int
bsd_writeblks(struct emul64 *emul64, ushort_t a_target, ushort_t a_lun,
		diskaddr_t blkno, int nblks, unsigned char *bufaddr)
{
	emul64_tgt_t	*tgt;
	blklist_t	*blk;
	emul64_rng_overlap_t overlap;
	avl_index_t	where;
	int		i = 0;

	if (emul64debug) {
		cmn_err(CE_CONT, "%s: bsd_writeblks: "
		    "<%d,%d> blk %llu (0x%llx) nblks %d\n",
		    emul64_name, a_target, a_lun, blkno, blkno, nblks);
	}

	emul64_yield_check();

	EMUL64_MUTEX_ENTER(emul64);
	tgt = find_tgt(emul64, a_target, a_lun);
	EMUL64_MUTEX_EXIT(emul64);
	if (tgt == NULL) {
		cmn_err(CE_WARN, "%s: bsd_writeblks: no target for %d,%d\n",
		    emul64_name, a_target, a_lun);
		goto unlocked_out;
	}

	if (emul64_collect_stats) {
		mutex_enter(&emul64_stats_mutex);
		emul64_io_ops++;
		emul64_io_blocks += nblks;
		mutex_exit(&emul64_stats_mutex);
	}
	mutex_enter(&tgt->emul64_tgt_blk_lock);

	/*
	 * Keep the ioctls from changing the nowrite list for the duration
	 * of this I/O by grabbing emul64_tgt_nw_lock.  This will keep the
	 * results from our call to bsd_tgt_overlap from changing while we
	 * do the I/O.
	 */
	rw_enter(&tgt->emul64_tgt_nw_lock, RW_READER);
	overlap = bsd_tgt_overlap(tgt, blkno, nblks);
	switch (overlap) {
	case O_SAME:
	case O_SUBSET:
		if (emul64_collect_stats) {
			mutex_enter(&emul64_stats_mutex);
			emul64_skipped_io++;
			emul64_skipped_blk += nblks;
			mutex_exit(&emul64_stats_mutex);
		}
		rw_exit(&tgt->emul64_tgt_nw_lock);
		mutex_exit(&tgt->emul64_tgt_blk_lock);
		return (0);
	case O_OVERLAP:
	case O_NONE:
		break;
	}
	for (i = 0; i < nblks; i++) {
		if ((overlap == O_NONE) ||
		    (bsd_tgt_overlap(tgt, blkno, 1) == O_NONE)) {
			/*
			 * If there was no overlap for the entire I/O range
			 * or if there is no overlap for this particular
			 * block, then we need to do the write.
			 */
			if (emul64_debug_blklist)
				cmn_err(CE_CONT, "%s: bsd_writeblks: "
				    "%d of %d: blkno %lld\n",
				    emul64_name, i+1, nblks, blkno);
			if (blkno > tgt->emul64_tgt_sectors) {
				cmn_err(CE_WARN, "%s: bsd_writeblks: "
				    "blkno %lld, tgt_sectors %lld\n",
				    emul64_name, blkno,
				    tgt->emul64_tgt_sectors);
				break;
			}

			blk = bsd_findblk(tgt, blkno, &where);
			if (bcmp(bufaddr, emul64_zeros, DEV_BSIZE) == 0) {
				if (blk) {
					bsd_freeblk(tgt, blk);
				}
			} else {
				if (blk) {
					(void) bcopy(bufaddr, blk->bl_data,
							DEV_BSIZE);
				} else {
					bsd_allocblk(tgt,
							blkno,
							(caddr_t)bufaddr,
							where);
				}
			}
		}
		blkno++;
		bufaddr += DEV_BSIZE;
	}

	/*
	 * Now that we're done with our I/O, allow the ioctls to change the
	 * nowrite list.
	 */
	rw_exit(&tgt->emul64_tgt_nw_lock);

errout:
	mutex_exit(&tgt->emul64_tgt_blk_lock);

unlocked_out:
	return ((nblks - i) * DEV_BSIZE);
}

emul64_tgt_t *
find_tgt(struct emul64 *emul64, ushort_t a_target, ushort_t a_lun)
{
	emul64_tgt_t	*tgt;

	tgt = emul64->emul64_tgt;
	while (tgt) {
		if (tgt->emul64_tgt_saddr.a_target == a_target &&
		    tgt->emul64_tgt_saddr.a_lun == a_lun) {
			break;
		}
		tgt = tgt->emul64_tgt_next;
	}
	return (tgt);

}

/*
 * Free all blocks that are part of the specified range.
 */
int
bsd_freeblkrange(emul64_tgt_t *tgt, emul64_range_t *range)
{
	blklist_t	*blk;
	blklist_t	*nextblk;

	ASSERT(mutex_owned(&tgt->emul64_tgt_blk_lock));
	for (blk = (blklist_t *)avl_first(&tgt->emul64_tgt_data);
		blk != NULL;
		blk = nextblk) {
		/*
		 * We need to get the next block pointer now, because blk
		 * will be freed inside the if statement.
		 */
		nextblk = AVL_NEXT(&tgt->emul64_tgt_data, blk);

		if (emul64_overlap(range, blk->bl_blkno, (size_t)1) != O_NONE) {
			bsd_freeblk(tgt, blk);
		}
	}
	return (0);
}

static blklist_t *
bsd_findblk(emul64_tgt_t *tgt, diskaddr_t blkno, avl_index_t *where)
{
	blklist_t	*blk;
	blklist_t	search;

	ASSERT(mutex_owned(&tgt->emul64_tgt_blk_lock));

	search.bl_blkno = blkno;
	blk = (blklist_t *)avl_find(&tgt->emul64_tgt_data, &search, where);
	return (blk);
}


static void
bsd_allocblk(emul64_tgt_t *tgt,
		diskaddr_t blkno,
		caddr_t data,
		avl_index_t where)
{
	blklist_t	*blk;

	if (emul64_debug_blklist)
		cmn_err(CE_CONT, "%s: bsd_allocblk: %llu\n",
		    emul64_name, blkno);

	ASSERT(mutex_owned(&tgt->emul64_tgt_blk_lock));

	blk = (blklist_t *)kmem_zalloc(sizeof (blklist_t), KM_SLEEP);
	blk->bl_data = (uchar_t *)kmem_zalloc(DEV_BSIZE, KM_SLEEP);
	blk->bl_blkno = blkno;
	(void) bcopy(data, blk->bl_data, DEV_BSIZE);
	avl_insert(&tgt->emul64_tgt_data, (void *) blk, where);

	if (emul64_collect_stats) {
		mutex_enter(&emul64_stats_mutex);
		emul64_nonzero++;
		tgt->emul64_list_length++;
		if (tgt->emul64_list_length > emul64_max_list_length) {
			emul64_max_list_length = tgt->emul64_list_length;
		}
		mutex_exit(&emul64_stats_mutex);
	}
}

static void
bsd_freeblk(emul64_tgt_t *tgt, blklist_t *blk)
{
	if (emul64_debug_blklist)
		cmn_err(CE_CONT, "%s: bsd_freeblk: <%d,%d> blk=%lld\n",
		    emul64_name, tgt->emul64_tgt_saddr.a_target,
		    tgt->emul64_tgt_saddr.a_lun, blk->bl_blkno);

	ASSERT(mutex_owned(&tgt->emul64_tgt_blk_lock));

	avl_remove(&tgt->emul64_tgt_data, (void *) blk);
	if (emul64_collect_stats) {
		mutex_enter(&emul64_stats_mutex);
		emul64_nonzero--;
		tgt->emul64_list_length--;
		mutex_exit(&emul64_stats_mutex);
	}
	kmem_free(blk->bl_data, DEV_BSIZE);
	kmem_free(blk, sizeof (blklist_t));
}

/*
 * Look for overlap between a nowrite range and a block range.
 *
 * NOTE:  Callers of this function must hold the tgt->emul64_tgt_nw_lock
 *	  lock.  For the purposes of this function, a reader lock is
 *	  sufficient.
 */
static emul64_rng_overlap_t
bsd_tgt_overlap(emul64_tgt_t *tgt, diskaddr_t blkno, int count)
{
	emul64_nowrite_t	*nw;
	emul64_rng_overlap_t	rv = O_NONE;

	for (nw = tgt->emul64_tgt_nowrite;
		(nw != NULL) && (rv == O_NONE);
		nw = nw->emul64_nwnext) {
		rv = emul64_overlap(&nw->emul64_blocked,
				    blkno,
				    (size_t)count);
	}
	return (rv);
}

/*
 * Operations that do a lot of I/O, such as RAID 5 initializations, result
 * in a CPU bound kernel when the device is an emul64 device.  This makes
 * the machine look hung.  To avoid this problem, give up the CPU from time
 * to time.
 */

static void
emul64_yield_check()
{
	static uint_t	emul64_io_count = 0;	/* # I/Os since last wait */
	static uint_t	emul64_waiting = FALSE;	/* TRUE -> a thread is in */
						/*   cv_timed wait. */
	clock_t		ticks;

	if (emul64_yield_enable == 0)
		return;

	mutex_enter(&emul64_yield_mutex);

	if (emul64_waiting == TRUE) {
		/*
		 * Another thread has already started the timer.  We'll
		 * just wait here until their time expires, and they
		 * broadcast to us.  When they do that, we'll return and
		 * let our caller do more I/O.
		 */
		cv_wait(&emul64_yield_cv, &emul64_yield_mutex);
	} else if (emul64_io_count++ > emul64_yield_period) {
		/*
		 * Set emul64_waiting to let other threads know that we
		 * have started the timer.
		 */
		emul64_waiting = TRUE;
		emul64_num_delay_called++;
		ticks = drv_usectohz(emul64_yield_length);
		if (ticks == 0)
			ticks = 1;
		(void) cv_timedwait(&emul64_yield_cv,
		    &emul64_yield_mutex, ddi_get_lbolt() + ticks);
		emul64_io_count = 0;
		emul64_waiting = FALSE;

		/* Broadcast in case others are waiting. */
		cv_broadcast(&emul64_yield_cv);
	}

	mutex_exit(&emul64_yield_mutex);
}