xref: /titanic_44/usr/src/cmd/smserverd/smediad.c (revision fb3fb4f3d76d55b64440afd0af72775dfad3bd1d)

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

#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include <syslog.h>
#include <signal.h>
#include <limits.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/mkdev.h>
#include <fcntl.h>
#include <sys/scsi/scsi.h>
#include <sys/scsi/generic/commands.h>
#include <string.h>
#include <door.h>
#include <pwd.h>
#include <thread.h>
#include <synch.h>
#include <pthread.h>
#include <locale.h>
#include <sys/resource.h>
#include <netconfig.h>
#include <sys/smedia.h>
#include "smserver.h"
#include <rpc/rpc.h>
#include "smed.h"
#include "myaudit.h"
#include <bsm/libbsm.h>
#include <bsm/audit_uevents.h>
#include <utmpx.h>


/*
 * The comments below would help in understanding what is being attempted
 * in the server.
 *
 * The server can be started either by inetd or by the client directly.
 * Normally the server is started by inetd when the client invokes the
 * appropriate libsmedia library call(smedia_get_handle).
 * However since the inetd runs only at init level 2 and above a mechanism
 * is provided for the server to be started if an attempt is made to use
 * the libsmedia calls in maintenence mode(init level 1).
 * The main() routine determines how the server was invoked and takes
 * the necessary action.
 * When started by inetd it registers itself as an RPC program.
 * The server also implements a mechanism by which it removes itself
 * after a period of inactivity. The period of inactivity is specified
 * by SVC_CLOSEDOWN which is set at 180 secs.
 * The logic of detecting inactivity is as follows:
 *
 * Two variables svcstate and svccount are used to determine if the server
 * is IDLE.
 * The svcstate is set to 1(_SERVED) when ever the server does any operation
 * on behalf of the client.
 * The svccount indicates the number of active clients who have established
 * a connection with the server. A connection is established when the
 * libsmedia call smedia_get_handle() succeeds.
 * The connection is broken when the client calls smedia_free_handle() OR
 * exits.
 * A thread called closedown is started up when server is started.
 * This thread runs periodically and monitors both svcstate and svccount.
 * If svcstate is IDLE and svccount is 0 then server exits.
 * The svcstate is set to IDLE by the closedown thread. It is set to _SERVED
 * by server. It is possible for the state to be _SERVED and the svccount
 * to be 0. The server could be kept busy by client calls of smedia_get_handle
 * that do not succeed. This is the reason for using both svcstate and svccount
 * to determine the true server state.
 *
 * The communication between client and server is thru door calls.
 * Below are the door descriptors available to communicate to the server.
 *
 * main_door_descriptor:
 * ---------------------
 * 	This is a predefined descriptor used by client to establish a
 * connection with the server. This descriptor is available to the client
 * as /var/adm/smedia_svc
 * The client uses the main_door_descriptor to obtain a dedicated
 * client_door_descriptor for itself. The smedia_get_handle call communicates
 * to the server using the main_door_descriptor and obtains the
 * client_door_descriptor which is stored in the handle structure.
 * All other libsmedia calls use the client_door_descriptor to communicate
 * with the server.
 *
 * client_door_descriptor:
 * -----------------------
 *	This is the door descriptor that is used by the clients to
 * request server to perform the necessary tasks. This door descriptor is
 * available only to the client for whom it was created.
 *
 * death_door_descriptor:
 * ----------------------
 * 	The sole function of this descriptor HAD been to inform the server of
 * the untimely death of the client. This descriptor is no longer used, though
 * it is still created, as libsmedia expects to use it.  This descriptor's
 * service procedure had used pthread cancellation(5) to terminate the thread of
 * the associated client_door_descriptor.  The client_door_descriptor now
 * handles the scenarios where a door_call/client are aborted/terminated.
 *
 * main_servproc()
 * -------------
 *	This is the routine associated with the main_door_descriptor.
 * This is the routine that handles the smedia_get_handle() call
 * of the client. If the door call to this routine succeeds it creates a
 * client_door_descriptor that is used by the client in subsequent library
 * calls.
 * This client_door_descriptor is passed to the client thru the door_return
 * call. This client_door_descriptor cannot be used by any other process other
 * than the client process that obtained it.
 * In addition to the client_door_descriptor a death_door_descriptor is also
 * created by the main server and passed on to the client. The client does not
 * use the death_door_descriptor.
 *
 * client_servproc()
 * ---------------
 *	This is the routine that handles the libsmedia calls of the
 * client. In the current implementation the server takes control of the
 * number of threads that handle the door calls. This is done by creating the
 * door descriptor as DOOR_PRIVATE.
 * The server runs only one thread per handle. This makes the implementation
 * simple as we do not have to use mutex to make the code MT safe.
 * The server thread has a data structure door_data_t associated with it.
 *
 * door_data_t
 * -----------
 * This is the data structure that is created by the main_servproc when it
 * creates the client_door_descriptor. The door mechanism has a way to associate
 * a cookie with the door descriptor. door_data_t is the cookie for the
 * client_door_descriptor. This cookie is passed to the server function that
 * handles the client_door_descriptor calls. In our case it is the
 * client_servproc routine.
 * The key elements of the door_data_t are the following:
 *
 *	dd_fd		file descriptor for the device.
 *	dd_buf		The shared memory buffer between client-server.
 *	dd_thread	The thread that handles the door_calls.
 *
 * signal handling:
 * ----------------
 *		The main purpose of trapping the signals is to exit gracefully
 * from the server after recording the appropriate message in the syslog.
 * This will help the administrator to determine the cause of failure of the
 * server by examining the log file.
 *
 * cleanup()
 * ---------
 *	This routine frees up all the resources allocated for the client.
 * Resources include the file descriptor, shared memory, threads.
 *
 * shared memory
 * -------------
 *	In order to reduce the overheads of moving large amounts of data
 * during raw read/write operations, the server uses the mmapped data of
 * client. The smedia_raw_read, smedia_raw_write library calls mmap the
 * memory and pass on the file descriptor that maps the memory to the server.
 * The server subsequently uses this mmapped memory during the IO.
 * If the mmapped memory changes in size, the server is informed and it
 * remaps the memory to the changed size.
 */
#ifdef DEBUG
#define	DEFAULT_VERBOSE		1
#define	DEFAULT_DEBUG		1
#else
#define	DEFAULT_VERBOSE		0
#define	DEFAULT_DEBUG		0
#endif

#define	N_BADSIGS		(sizeof (badsigs)/sizeof (badsigs[0]))
#define	MD_LEN			30
#define	MAXUGNAME		10
#define	SVC_CLOSEDOWN 		180

/*
 * We will NOT be permitting the following USCI cmd options.
 *
 * RESET of target
 * RESET of  Bus.
 * Tagged commands to device
 * Explicitly setting SYNC/ASYNC mode of operations.
 * POLLED MODE of operation.
 * Explicitly setting NO DISCONNECT features.
 * use of RESERVED flags.
 */
#define	FORBIDDEN_FLAGS		(USCSI_RESET | USCSI_RESET_ALL | USCSI_RENEGOT \
				| USCSI_ASYNC  | USCSI_SYNC | USCSI_NOINTR | \
				USCSI_NOTAG | USCSI_NOPARITY | USCSI_NODISCON \
				| USCSI_RESERVED)

/* States a server can be in wrt request */

#define	_IDLE 0
#define	_SERVED 1

static char		*prog_name;
static int svcstate = _IDLE;	/* Set when a request is serviced */
static int svccount = 0;	/* Number of requests being serviced */
static int svcstart_level = 0;	/* init level when server was started */
static mutex_t svcstate_lock;	/* lock for svcstate, svccount */

extern	void smserverprog_1(struct svc_req *, SVCXPRT *);

/*
 * Log messages
 */
#define	SIGACT_FAILED	"Failed to install signal handler for %s: %s"
#define	BADSIG_MSG	"Thread %d Caught signal %d addr=%p trapno=%d pc=%p"

static int	badsigs[] = {SIGSEGV, SIGBUS, SIGFPE, SIGILL};

/* global variables */
int		verbose		= DEFAULT_VERBOSE;
int		debug_level	= DEFAULT_DEBUG;
char		*smediad_devdir = DEFAULT_SMEDIAD_DEVDIR;

thread_key_t	door_key;

server_data_t	server_data;

static int	server_door, server_fd;

static int32_t do_uscsi_cmd(int32_t file, struct uscsi_cmd *uscsi_cmd,
		int32_t flag);
static void client_servproc(void *cookie, char *argp, size_t arg_size,
		door_desc_t *dp, uint_t ndesc);
static void cleanup(door_data_t *);
static void *init_server(void *);
static int32_t scsi_reassign_block(int32_t fd, diskaddr_t);
static int32_t get_mode_page(int32_t fd, uchar_t pc, uchar_t page_code,
	uchar_t *md_data, uchar_t data_len);
static int32_t get_device_type(char *v_name);
static int32_t get_device_type_scsi(int32_t fd, struct scsi_inquiry *inq);

static int32_t scsi_format(int32_t fd, uint_t flavor, uint_t mode);
static int32_t scsi_media_status(int32_t fd);
static int32_t scsi_write_protect(int32_t fd, smwp_state_t *wp);
static int32_t scsi_floppy_media_status(int32_t fd);
static int32_t scsi_floppy_write_protect(int32_t fd, smwp_state_t *wp);
static int32_t scsi_floppy_format(int32_t, uint_t, uint_t);
static int32_t get_floppy_geom(int32_t fd, uint32_t capacity,
			struct dk_geom *dkgeom);
static int32_t get_media_capacity(int32_t fd, uint32_t *capacity,
			uint32_t *blocksize);

static int32_t scsi_ls120_format(uint_t fd, uint_t flavor, uint32_t capacity,
			uint32_t blocksize);

static void *sm_server_thread(void *arg);
static void sm_door_server_create(door_info_t *dip);
static void term_handler(int sig, siginfo_t *siginfo, void *sigctx);
static void hup_handler(int sig, siginfo_t *siginfo, void *sigctx);
static void sig_handler(int sig, siginfo_t *siginfo, void *sigctx);
static void badsig_handler(int sig, siginfo_t *siginfo, void *sigctx);
static void server_badsig_handler(int sig, siginfo_t *siginfo, void *sigctx);
static char *xlate_state(int32_t);
static uint32_t	get_sector_size(int fd);
static int32_t raw_read(door_data_t *door_dp, smedia_services_t *req);
static int32_t raw_write(door_data_t *door_dp, smedia_services_t *req);
static int32_t reassign_block(door_data_t *door_dp, smedia_services_t *req);
static int32_t set_protection_status(door_data_t *door_dp,
			smedia_services_t *req);
static int32_t set_shfd(door_data_t *door_dp, int32_t fd,
			smedia_services_t *req);

static void door_ret_err(smedia_reterror_t *reterror, int32_t err);
static void my_door_return(char *data_ptr, size_t data_size,
			door_desc_t *desc_ptr, uint_t num_desc);
static int32_t invalid_uscsi_operation(door_data_t *, struct uscsi_cmd *);

#define	W_E_MASK	0x80

static smserver_info server_info;

static int32_t
invalid_uscsi_operation(door_data_t *door_dp, struct uscsi_cmd *ucmd)
{

	if (door_dp->dd_dkinfo.dki_ctype != DKC_CDROM) {
		debug(5,
		"Invalid device type(0x%x) found for uscsi cmd.\n",
			door_dp->dd_dkinfo.dki_ctype);
		errno = EINVAL;
		return (EINVAL);
	}
	if (ucmd->uscsi_flags & FORBIDDEN_FLAGS) {
		debug(5,
		"Invalid flags(0x%x) set in uscsi cmd. cdb[0]=0x%x\n",
		ucmd->uscsi_flags,  ucmd->uscsi_cdb[0]);
		errno = EINVAL;
		return (EINVAL);
	}
	if (ucmd->uscsi_cdb[0] == SCMD_COPY ||
	    ucmd->uscsi_cdb[0] == SCMD_COPY_VERIFY ||
	    ucmd->uscsi_cdb[0] == SCMD_COMPARE ||
	    ucmd->uscsi_cdb[0] == SCMD_WRITE_BUFFER) {
		debug(5,
		"Invalid command(0x%x) found in cdb.\n",
		ucmd->uscsi_cdb[0]);
		errno = EINVAL;
		return (EINVAL);
	}
	return (0);
}

static uint32_t
get_sector_size(int fd)
{
	uint32_t	sector_size;
	struct uscsi_cmd	ucmd;
	union scsi_cdb		cdb;
	int32_t		ret_val;
	uint32_t rc_data[2];
	char rq_data[RQ_LEN];

	cdb.scc_cmd = SCMD_READ_CAPACITY;
	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP1;
	ucmd.uscsi_bufaddr = (caddr_t)&rc_data;
	ucmd.uscsi_buflen = sizeof (rc_data);
	ucmd.uscsi_timeout = 120; /* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;

	ret_val = do_uscsi_cmd(fd,
		&ucmd, USCSI_READ|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "Read capacity : %d - %d errno = %d\n",
			ret_val, ucmd.uscsi_status, errno);
		sector_size = 512;
	} else {
		sector_size = ntohl(rc_data[1]);
	}
	debug(5, "sector size = 0x%x(%d)\n",
		sector_size, sector_size);
	return (sector_size);
}

static char *
xlate_state(int32_t state)
{
	switch (state) {

	case SM_WRITE_PROTECT_DISABLE:
		return ("PROTECTION_DISABLED");
	case SM_WRITE_PROTECT_PASSWD:
		return ("WRITE_PROTECT_PASSWD");
	case SM_WRITE_PROTECT_NOPASSWD:
		return ("WRITE_PROTECT_NOPASSWD");
	case SM_READ_WRITE_PROTECT:
		return ("READ_WRITE_PROTECT");
	case SM_TEMP_UNLOCK_MODE:
		return ("PROTECTION DISABLED");
	default:
		return ("UNKNOWN_STATE");
	}
}

static char *
xlate_cnum(smedia_callnumber_t cnum)
{
	switch (cnum) {

	case SMEDIA_CNUM_OPEN_FD:
		return ("SMEDIA_CNUM_OPEN_FD");
	case SMEDIA_CNUM_GET_DEVICE_INFO:
		return ("SMEDIA_CNUM_GET_DEVICE_INFO");
	case SMEDIA_CNUM_GET_MEDIUM_PROPERTY:
		return ("SMEDIA_CNUM_GET_MEDIUM_PROPERTY");
	case SMEDIA_CNUM_GET_PROTECTION_STATUS:
		return ("SMEDIA_CNUM_GET_PROTECTION_STATUS");
	case SMEDIA_CNUM_SET_PROTECTION_STATUS:
		return ("SMEDIA_CNUM_SET_PROTECTION_STATUS");
	case SMEDIA_CNUM_RAW_READ:
		return ("SMEDIA_CNUM_RAW_READ");
	case SMEDIA_CNUM_RAW_WRITE:
		return (" SMEDIA_CNUM_RAW_WRITE");
	case SMEDIA_CNUM_FORMAT:
		return ("SMEDIA_CNUM_FORMAT");
	case SMEDIA_CNUM_CHECK_FORMAT_STATUS:
		return ("SMEDIA_CNUM_CHECK_FORMAT_STATUS");
	case SMEDIA_CNUM_EJECT:
		return ("SMEDIA_CNUM_EJECT");
	case SMEDIA_CNUM_REASSIGN_BLOCK:
		return ("SMEDIA_CNUM_REASSIGN_BLOCK");
	case SMEDIA_CNUM_SET_SHFD:
		return ("SMEDIA_CNUM_SET_SHFD");
	case SMEDIA_CNUM_PING:
		return ("SMEDIA_CNUM_PING");
	case SMEDIA_CNUM_USCSI_CMD:
		return ("SMEDIA_CNUM_USCSI_CMD");
	default:
		return ("UNKNOWN_CNUM");
	}
}

/*ARGSUSED*/
smserver_info *
smserverproc_get_serverinfo_1(void *argp, CLIENT *clnt)
{
	(void) mutex_lock(&svcstate_lock);
	svcstate = _SERVED;
	(void) mutex_unlock(&svcstate_lock);
	server_info.vernum = SMSERVERVERS;
	server_info.status = 0;
	(void) mutex_lock(&server_data.sd_init_lock);
	if (server_data.sd_init_state == INIT_NOT_DONE) {
		server_data.sd_init_state = INIT_IN_PROGRESS;
		debug(5, "Initialising server\n");
		(void) init_server(NULL);
	}
	if (server_data.sd_init_state != INIT_DONE) {
		debug(1, "init_server did not do the job. "
		    "init_state=%d\n", server_data.sd_init_state);
		server_data.sd_init_state = INIT_NOT_DONE;
		(void) mutex_unlock(&server_data.sd_init_lock);
		server_info.status = -1;
		return (&server_info);
	}
	(void) mutex_unlock(&server_data.sd_init_lock);

	debug(5, "smserverproc thread %d running....\n", pthread_self());
	return (&server_info);
}

/*ARGSUSED*/
static void
server_badsig_handler(int sig, siginfo_t *siginfo, void *sigctx)
{

	fatal(gettext(BADSIG_MSG), pthread_self(), sig, siginfo->si_addr,
		siginfo->si_trapno,
		siginfo->si_pc);
}

static int32_t
do_uscsi_cmd(int32_t file, struct uscsi_cmd *uscsi_cmd, int32_t	flag)
{
	int32_t	ret_val;

	/*
	 * Set function flags for driver.
	 */
	uscsi_cmd->uscsi_flags = USCSI_ISOLATE;

#ifdef DEBUG
	uscsi_cmd->uscsi_flags |= USCSI_DIAGNOSE;
#else
	uscsi_cmd->uscsi_flags |= USCSI_SILENT;
#endif /* DEBUG */

	uscsi_cmd->uscsi_flags |= flag;

	errno = 0;
	ret_val = ioctl(file, USCSICMD, uscsi_cmd);
	if (ret_val == 0 && uscsi_cmd->uscsi_status == 0) {
		return (ret_val);
	}
	if (!errno)
		errno = EIO;
	return (-1);
}

static int32_t
get_device_type(char *v_name)
{
	int32_t i;

	for (i = 0; i < 8; i++) {
		v_name[i] = toupper(v_name[i]);
	}
	if (strstr(v_name, "IOMEGA")) {
		return (SCSI_IOMEGA);
	}
	if (strstr(v_name, "FD") ||
	    strstr(v_name, "LS-120")) {
		return (SCSI_FLOPPY);
	}
	return (SCSI_GENERIC);

}

static int32_t
get_device_type_scsi(int32_t fd, struct scsi_inquiry *inq)
{
	int32_t dev_type;
	struct uscsi_cmd ucmd;
	union scsi_cdb  cdb;
	int32_t	ret_val;
	char rq_data[RQ_LEN];

	(void) memset((void *) inq, 0, sizeof (struct scsi_inquiry));
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (union scsi_cdb));
	cdb.scc_cmd = SCMD_INQUIRY;
	FORMG0COUNT(&cdb, sizeof (struct scsi_inquiry));
	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP0;
	ucmd.uscsi_bufaddr = (caddr_t)inq;
	ucmd.uscsi_buflen = sizeof (struct scsi_inquiry);
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_READ|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "INQUIRY failed: rv = %d  uscsi_status = "
		    "%d  errno = %d\n", ret_val, ucmd.uscsi_status, errno);
		return (-1);
	}

	dev_type = get_device_type(inq->inq_vid);

	debug(5, "dev_type %d\n", dev_type);
	return (dev_type);

}

static int32_t
get_media_capacity(int32_t fd, uint32_t *capacity, uint32_t *blocksize)
{
	struct uscsi_cmd ucmd;
	uchar_t cdb[12];
	int32_t ret_val;
	uchar_t data[20];
	char rq_data[RQ_LEN];

	debug(5, "get_media_capacity:\n");

	(void) memset((void *)&data, 0, sizeof (data));
	(void) memset((void *)&ucmd, 0, sizeof (ucmd));
	(void) memset((void *)&cdb, 0, sizeof (cdb));

	/* retrieve size discriptor of inserted media */
	cdb[0] = SCMD_READ_FORMAT_CAP;
	cdb[8] = 0x14;  /* data size */

	/* Fill in the USCSI fields */
	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP5;
	ucmd.uscsi_bufaddr = (caddr_t)data;
	ucmd.uscsi_buflen = sizeof (data);
	ucmd.uscsi_timeout = 120;
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_READ|USCSI_RQENABLE);

	if (ret_val || ucmd.uscsi_status) {
		debug(5, "Retrieving media info failed: %d - %d\n", ret_val,
		    ucmd.uscsi_status);

		if ((rq_data[2] == KEY_DATA_PROTECT) && (rq_data[12] == 0x30) &&
		    (rq_data[13] == 0)) {
			(void) debug(1, "Invalid command for media\n");
			errno = EINVAL;
		}
		return (-1);
	}

	/* No media, bail out */
	if (data[8] == 0x3) {
		(void) debug(5, "no media in drive\n");
		return (-1);
	}

	/*
	 * Generate capacity and blocksize information
	 */

	*capacity =  (uint32_t)((data[4] << 24) + (data[5] << 16) +
	    (data[6] << 8) + data[7]);

	debug(1, "capacity is %x %x %x %x = %x", data[4], data[5], data[6],
	    data[7], *capacity);

	*blocksize = (uint32_t)((data[9] << 16) + (data[10] << 8) + data[11]);

	return (0);
}

static int32_t
scsi_zip_format(int32_t fd, uint_t flavor, uint_t mode)
{
	struct uscsi_cmd ucmd;
	struct scsi_inquiry inq;
	uchar_t cdb[12];
	int32_t   ret_val;
	uchar_t data[4];
	uint32_t rc_data[2];
	char rq_data[RQ_LEN];
	uint32_t capacity;


	if ((mode != SM_FORMAT_IMMEDIATE) &&
		(mode != SM_FORMAT_BLOCKED)) {
		errno = ENOTSUP;
		return (ENOTSUP);
	}
	/*
	 * Do an inquiry and try to figure out if it an
	 * IOMEGA JAZ 2GB device.
	 */

	(void) memset((void *) &inq, 0, sizeof (inq));
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (cdb));
	(void) memset((void *) &rq_data, 0, sizeof (rq_data));
	cdb[0] = SCMD_INQUIRY;
	cdb[4] = sizeof (inq);
	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP0;
	ucmd.uscsi_bufaddr = (caddr_t)&inq;
	ucmd.uscsi_buflen = sizeof (inq);
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_READ|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "inquiry failed: %d - %d errno = %d\n",
			ret_val, ucmd.uscsi_status, errno);
		return (ucmd.uscsi_status);
	}

	(void) memset((void *) &rc_data, 0, sizeof (rc_data));
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (cdb));
	cdb[0] = SCMD_READ_CAPACITY;
	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP1;
	ucmd.uscsi_bufaddr = (caddr_t)&rc_data;
	ucmd.uscsi_buflen = sizeof (rc_data);
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */

	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_READ);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "Read capacity : %d - %d errno = %d\n",
			ret_val, ucmd.uscsi_status, errno);
		return (ucmd.uscsi_status);
	}

	capacity = ntohl(rc_data[0]);

	(void) memset((void *)&data, 0, sizeof (data));
	(void) memset((void *)&ucmd, 0, sizeof (ucmd));
	(void) memset((void *)&cdb, 0, sizeof (cdb));
	cdb[0] =  SCMD_FORMAT;
	/*
	 * Defect list sent by initiator is a complete list of defects.
	 */
	cdb[1] = (FMTDATA | CMPLIST);
	/*
	 * Target should examine the setting of the DPRY, DCRT, STPF, IP
	 * and DSP bits.
	 */
	data[1] = FOV;

	switch (flavor) {
		case SM_FORMAT_QUICK :
			/*
			 * Target should not perform any vendor specific
			 * medium certification process or format verification
			 */
			data[1] = (FOV | DCRT);
			/*
			 * Defect list sent is an addition to the existing
			 * list of defects.
			 */
			cdb[1] =  FMTDATA;
			break;
		case SM_FORMAT_FORCE :
			if (strstr(inq.inq_pid, "jaz")) {
				debug(1,
				"LONG Format of JAZ media not supported\n");
				errno = ENOTSUP;
				return (ENOTSUP);
			}
			/*
			 * Formatting a write-protected or read/write
			 * protected cartridge is allowed.
			 * This is a vendor specific Format Option.
			 */
			cdb[2] = 0x20;
			break;
		case SM_FORMAT_LONG :
			if (strstr(inq.inq_pid, "jaz")) {
				debug(1,
				"LONG Format of JAZ media not supported\n");
				errno = ENOTSUP;
				return (ENOTSUP);
			}
			/*
			 * Defect list sent is an addition to the existing
			 * list of defects.
			 */
			cdb[1] = FMTDATA;
			break;
		default :
			debug(1, "Format option %d not supported!!\n",
			flavor);
			errno = ENOTSUP;
			return (ENOTSUP);
	}

	if (mode == SM_FORMAT_IMMEDIATE) {
		data[1] |= IMMED;
		debug(5, "immediate_flag set\n");
	}

	ucmd.uscsi_cdb = (caddr_t)&cdb;
	debug(5, "cdb: %x ", cdb[0]);
	debug(5, "%x %x ", cdb[1], cdb[2]);
	debug(5, "%x %x %x\n", cdb[3], cdb[4], cdb[5]);
	debug(5, "data: %x %x %x %x\n", data[0], data[1], data[2], data[3]);

	ucmd.uscsi_cdblen = CDB_GROUP0;
	ucmd.uscsi_bufaddr = (caddr_t)data;
	ucmd.uscsi_buflen = sizeof (data);
	ucmd.uscsi_timeout = FORMAT_TIMEOUT(capacity);
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_WRITE|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "Format failed : %d - uscsi_status = %d errno = %d\n",
			ret_val,
			ucmd.uscsi_status, errno);
		if ((rq_data[2] == KEY_DATA_PROTECT) ||
			(rq_data[2] == KEY_ILLEGAL_REQUEST))
			errno = EINVAL;
		if ((rq_data[2] == KEY_MEDIUM_ERROR) ||
			(rq_data[2] == KEY_HARDWARE_ERROR))
			errno = EIO;
		return (errno);
	}

	return (0);
}

static int32_t
scsi_ls120_format(uint_t fd, uint_t flavor, uint32_t capacity,
    uint32_t blocksize)
{
	struct uscsi_cmd ucmd;
	uchar_t cdb[12];
	int32_t ret_val;
	uchar_t data[12];
	char	rq_data[RQ_LEN];

	debug(5, "scsi_ls120_format:\n");

	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (cdb));
	(void) memset((void *) &rq_data, 0, sizeof (rq_data));

	cdb[0] = SCMD_FORMAT;
	cdb[1] = (FMTDATA | 0x7);
	cdb[8] = 0x0C; /* parameter list length */

	data[1] = 0x80;
	data[3] = 0x08;


	data[4] = (capacity >> 24) & 0xff;
	data[5] = (capacity >> 16) & 0xff;
	data[6] = (capacity >> 8) & 0xff;
	data[7] = capacity & 0xff;


	data[9] =  (blocksize >> 16) & 0xff;
	data[10] = (blocksize >> 8) & 0xff;
	data[11] = blocksize & 0xff;

	debug(5, "cdb: %x %x %x ... %x", cdb[0], cdb[1], cdb[2], cdb[8]);
	debug(5, "data: %x %x %x %x\n", data[0], data[1], data[2], data[3]);
	debug(5, "    : %x %x %x %x\n", data[4], data[5], data[6], data[7]);
	debug(5, "    : %x %x %x %x\n", data[8], data[9], data[10], data[11]);

	switch (flavor) {
		case SM_FORMAT_QUICK :
			debug(1, "Format not supported\n");
			errno = ENOTSUP;
			return (-1);
		case SM_FORMAT_FORCE :
			break;
		case SM_FORMAT_LONG :
			break;
		default :
			debug(1, "Format option not specified!!\n");
			errno = ENOTSUP;
			return (-1);
	}

	ucmd.uscsi_cdb = (caddr_t)&cdb;


	ucmd.uscsi_cdblen = CDB_GROUP5;
	ucmd.uscsi_bufaddr = (caddr_t)data;
	ucmd.uscsi_buflen = sizeof (data);
	ucmd.uscsi_timeout = 0x12c0;
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	(void) fflush(stdout);

	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_WRITE|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		debug(1, "Format failed failed: %d - %d\n", ret_val,
		    ucmd.uscsi_status);

		if ((rq_data[2] == KEY_DATA_PROTECT) &&
		    (rq_data[12] == 0x30) && (rq_data[13] == 0)) {

			debug(1, "Invalid command for media\n");
			errno = EINVAL;
		}

		if ((rq_data[2] == KEY_NOT_READY) && (rq_data[12] == 0x30)) {
			debug(1, "Incompatible media.\n");
			errno = EINVAL;
		}

		return (-1);
	}

	return (0);
}

static int32_t
scsi_format(int32_t fd, uint_t flavor, uint_t mode)
{
	struct uscsi_cmd ucmd;
	struct scsi_inquiry inq;
	uchar_t cdb[12];
	int32_t   ret_val;
	uchar_t data[4];
	char rq_data[RQ_LEN];
	uint32_t rc_data[2];
	uint32_t capacity;



	if ((mode != SM_FORMAT_IMMEDIATE) &&
		(mode != SM_FORMAT_BLOCKED)) {
		errno = ENOTSUP;
		return (-1);
	}

	/*
	 * Do an inquiry and try to figure out if it an
	 * IOMEGA JAZ 2GB device.
	 */

	(void) memset((void *) &inq, 0, sizeof (inq));
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (cdb));
	(void) memset((void *) &rq_data, 0, sizeof (rq_data));
	cdb[0] = SCMD_INQUIRY;
	cdb[4] = sizeof (inq);
	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP0;
	ucmd.uscsi_bufaddr = (caddr_t)&inq;
	ucmd.uscsi_buflen = sizeof (inq);
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_READ|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "inquiry failed: %d - %d errno = %d\n",
			ret_val, ucmd.uscsi_status, errno);
		return (ucmd.uscsi_status);
	}

	(void) memset((void *) &rc_data, 0, sizeof (rc_data));
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (cdb));
	cdb[0] = SCMD_READ_CAPACITY;
	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP1;
	ucmd.uscsi_bufaddr = (caddr_t)&rc_data;
	ucmd.uscsi_buflen = sizeof (rc_data);
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */

	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_READ);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "Read capacity : %d - %d errno = %d\n",
			ret_val, ucmd.uscsi_status, errno);
		return (ucmd.uscsi_status);
	}

	capacity = ntohl(rc_data[0]);

	(void) memset((void *)&data, 0, sizeof (data));
	(void) memset((void *)&ucmd, 0, sizeof (ucmd));
	(void) memset((void *)&cdb, 0, sizeof (cdb));
	cdb[0] =  SCMD_FORMAT;
	/*
	 * Defect list sent is an addition to the existing
	 * list of defects.
	 */
	cdb[1] =  FMTDATA;
	/*
	 * Target should examine the setting of the DPRY, DCRT, STPF, IP
	 * and DSP bits.
	 */
	data[1] = FOV;

	if (mode == SM_FORMAT_IMMEDIATE) {
		debug(5,
	"SM_FORMAT_IMMEDIATE specified ignored. Performing a long format!\n");
	}

	switch (flavor) {
		case SM_FORMAT_LONG :
			if (strstr(inq.inq_pid, "jaz")) {
				debug(1,
				"LONG Format of JAZ media not supported\n");
				errno = ENOTSUP;
				return (ENOTSUP);
			}
			/*
			 * Defect list sent is an addition to the existing
			 * list of defects.
			 */
			cdb[1] = FMTDATA;
			break;
		default :
			debug(1, "Format option %d  not supported!!\n",
			flavor);
			errno = ENOTSUP;
			return (ENOTSUP);
	}


	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP0;
	ucmd.uscsi_bufaddr = (caddr_t)data;
	ucmd.uscsi_buflen = sizeof (data);
	ucmd.uscsi_timeout = FORMAT_TIMEOUT(capacity);
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_WRITE|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "Format failed failed: %d - %d errno = %d\n",
			ret_val, ucmd.uscsi_status, errno);
		return (ucmd.uscsi_status);
	}

	return (0);
}

static int32_t
scsi_media_status(int32_t fd)
{
	struct mode_header modeh;
	struct uscsi_cmd ucmd;
	union scsi_cdb  cdb;
	int32_t ret_val;
	int32_t cur_status;
	char rq_data[RQ_LEN];

	debug(10, "SCSI MEDIA STATUS CALLED \n");

	(void) memset((void *) &modeh, 0, sizeof (modeh));
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (union scsi_cdb));
	cdb.scc_cmd = SCMD_MODE_SENSE;
	FORMG0COUNT(&cdb, sizeof (modeh));
	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP0;
	ucmd.uscsi_bufaddr = (caddr_t)&modeh;
	ucmd.uscsi_buflen = sizeof (modeh);
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_READ|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "Modesense failed: %d - %d errno = %d\n",
			ret_val, ucmd.uscsi_status, errno);
		return (-1);
	}


	if (modeh.device_specific & W_E_MASK) {
		cur_status = SM_WRITE_PROTECT_NOPASSWD;
	} else {
		cur_status = SM_WRITE_PROTECT_DISABLE;
	}
	debug(5, "cur status %d\n", cur_status);

	return (cur_status);
}

static int32_t
scsi_zip_media_status(int32_t fd)
{
	struct uscsi_cmd ucmd;
	uchar_t cdb[12];
	int32_t	status;
	int32_t mode;
	uchar_t data[64];
	char rq_data[RQ_LEN];

	debug(10, "Getting media status\n");

	(void) memset((void *)&ucmd, 0, sizeof (ucmd));
	(void) memset((void *)&cdb, 0, sizeof (cdb));

	cdb[0] = IOMEGA_NONSENSE_CMD;
	cdb[2] = CARTRIDGE_STATUS_PAGE;
	cdb[4] = ND_LENGTH;
	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP0;
	ucmd.uscsi_bufaddr = (caddr_t)data;
	ucmd.uscsi_buflen = 64;
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	status = do_uscsi_cmd(fd, &ucmd, USCSI_READ|USCSI_RQENABLE);
	if (status || ucmd.uscsi_status) {
		debug(5, "Cartridge protect operation failed: "
		    "rv = %d  uscsi_status = %d  errno = %d\n",
		    status, ucmd.uscsi_status, errno);
		return (-1);
	}

	if (data[DISK_STATUS_OFFSET + NON_SENSE_HDR_LEN] == 4) {
		debug(1, "Disk not present. \n");
		return (-1);
	}
	mode = data[PROTECT_MODE_OFFSET + NON_SENSE_HDR_LEN] & 0xF;

	debug(5, "MODE 0x%x / %d.\n", mode, mode);

	switch (mode) {
		case UNLOCK_MODE:
			status = SM_WRITE_PROTECT_DISABLE;
			break;
		case WRITE_PROTECT_MODE:
			status = SM_WRITE_PROTECT_NOPASSWD;
			break;
		case PASSWD_WRITE_PROTECT_MODE:
			status = SM_WRITE_PROTECT_PASSWD;
			break;
		case READ_WRITE_PROTECT_MODE:
			status = SM_READ_WRITE_PROTECT;
			break;
		default :
			if (mode & TEMP_UNLOCK_MODE)
				status = SM_TEMP_UNLOCK_MODE;
			else
				status = SM_STATUS_UNKNOWN;
			break;
	}

	debug(5, "status %d \n", status);
	return (status);
}

static int32_t
scsi_reassign_block(int32_t fd, diskaddr_t block)
{
	uchar_t data[8];
	struct uscsi_cmd ucmd;
	char cdb[12];
	int32_t	ret_val;
	char rq_data[RQ_LEN];

	debug(5, "SCSI REASSIGN CALLED block = %lld\n", block);

	(void) memset((void *) &data, 0, sizeof (data));
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (cdb));
	cdb[0] = SCMD_REASSIGN_BLOCK;
	data[3] = 4;
	data[4] = ((block & 0xFF000000) >> 24);
	data[5] = ((block & 0xFF0000) >> 16);
	data[6] = ((block & 0xFF00) >> 8);
	data[7] = block & 0xFF;

	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP0;
	ucmd.uscsi_bufaddr = (caddr_t)data;
	ucmd.uscsi_buflen = sizeof (data);
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_WRITE|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "Reassign block failed: %d - %d errno = %d\n",
			ret_val, ucmd.uscsi_status, errno);
		return (-1);
	}

	return (0);
}

static int32_t
get_mode_page(int32_t fd, uchar_t pc, uchar_t page_code,
    uchar_t *md_data, uchar_t data_len)
{
	struct uscsi_cmd ucmd;
	uchar_t cdb[12];
	int32_t	ret_val;
	char rq_data[RQ_LEN];

	debug(10, "MODE SENSE(6) - page_code = 0x%x\n", page_code);

	(void) memset((void *) md_data, 0, sizeof (data_len));
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (cdb));
	cdb[0] = SCMD_MODE_SENSE;
	cdb[2] = (pc << 6) | page_code;
	cdb[4] = data_len;

	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP0;
	ucmd.uscsi_bufaddr = (caddr_t)md_data;
	ucmd.uscsi_buflen = data_len;
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_READ|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "Modesense failed: %d - %d errno = %d\n",
			ret_val, ucmd.uscsi_status, errno);
		return (-2);
	}

	return (0);
}

static int32_t
scsi_zip_write_protect(int32_t fd, smwp_state_t *wp)
{
	struct uscsi_cmd ucmd;
	struct scsi_inquiry inq;
	uchar_t cdb[12];
	int32_t	status;
	int32_t new_mode;
	char rq_data[RQ_LEN];
	int32_t wa_bit;
	char *tmp_passwd = NULL;

	debug(10, "SCSI ZIP WRITE PROTECT CALLED \n");

	/*
	 * Do an inquiry and try to figure out if it an
	 * ATAPI or SCSI device.
	 */

	(void) memset((void *) &inq, 0, sizeof (inq));
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (cdb));
	(void) memset((void *) &rq_data, 0, sizeof (rq_data));
	cdb[0] = SCMD_INQUIRY;
	cdb[4] = sizeof (inq);
	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP0;
	ucmd.uscsi_bufaddr = (caddr_t)&inq;
	ucmd.uscsi_buflen = sizeof (inq);
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	status = do_uscsi_cmd(fd, &ucmd, USCSI_READ|USCSI_RQENABLE);
	if (status || ucmd.uscsi_status) {
		debug(5, "inquiry failed: %d - %d errno = %d\n",
			status, ucmd.uscsi_status, errno);
		return (-1);
	}

	if (inq.inq_ansi > 0) {
		wa_bit = 0;
		debug(5, "SCSI device\n");
	} else {
		wa_bit = 1;
		debug(5, "ATAPI device\n");
	}

	switch (wp->sm_new_state) {
		case SM_WRITE_PROTECT_DISABLE :
			new_mode = 0x0;
			break;
		case SM_WRITE_PROTECT_NOPASSWD :
			new_mode = 0x2;
			break;
		case SM_WRITE_PROTECT_PASSWD :
			new_mode = 0x3;
			break;
		case SM_READ_WRITE_PROTECT :
			new_mode = 0x5;
			break;
		case SM_TEMP_UNLOCK_MODE :
			new_mode = 0x8;
			break;
		default :
			debug(1, "Invalid mode 0x%x specified\n",
			wp->sm_new_state);
			errno = ENOTSUP;
			return (-1);
	}


	(void) memset((void *)&ucmd, 0, sizeof (ucmd));
	(void) memset((void *)&cdb, 0, sizeof (cdb));
	(void) memset((void *) &rq_data, 0, sizeof (rq_data));
	cdb[0] = IOMEGA_CATRIDGE_PROTECT;
	cdb[1] |= new_mode;
	if (wa_bit)
		cdb[1] |= WA_BIT;
	cdb[4] = wp->sm_passwd_len;
	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP0;
	if (wa_bit && (wp->sm_passwd_len & 1)) {
		/*
		 * Oops, ATAPI device with an odd length passwd!
		 * Allocate a buffer to hold one extra byte.
		 */
		debug(5, "Odd len passwd for ATAPI device!\n");
		errno = 0;
		tmp_passwd = (char *)malloc(wp->sm_passwd_len+1);
		if (tmp_passwd == NULL) {
			if (errno == 0)
				errno = ENOMEM;
			return (-1);
		}
		(void) memset(tmp_passwd, 0, wp->sm_passwd_len+1);
		(void) memcpy(tmp_passwd, wp->sm_passwd, wp->sm_passwd_len);
		ucmd.uscsi_bufaddr = (caddr_t)tmp_passwd;
		ucmd.uscsi_buflen = wp->sm_passwd_len+1;
	} else {
		ucmd.uscsi_bufaddr = (caddr_t)wp->sm_passwd;
		ucmd.uscsi_buflen = wp->sm_passwd_len;
	}
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	status = do_uscsi_cmd(fd, &ucmd, USCSI_WRITE|USCSI_RQENABLE);
	if (tmp_passwd != NULL) {
		free(tmp_passwd);
	}
	if (status || ucmd.uscsi_status) {
		debug(5, "Cartridge-protect operation failed: rv "
		    "= %d  uscsi_status = %d  errno = %d\n", status,
		    ucmd.uscsi_status, errno);
		if ((rq_data[2] & 0xF) == KEY_ILLEGAL_REQUEST) {
			if (rq_data[12] == 0x26) {
				/* Wrong passwd */
				debug(5, "Protection Request with wrong "
				    "passwd. errno is being set to EACCES.\n");
				errno = EACCES;
			}
		}
		return (-1);
	}

	return (0);
}

/*ARGSUSED*/
static int32_t
scsi_write_protect(int32_t fd, smwp_state_t *wp)
{
	errno = ENOTSUP;
	return (-1);
}

/*
 * This thread becomes the server-side thread used in
 * the implementation of a door_call between a client
 * and the Client Door.
 *
 * This thread is customized both by the door_server_create(3c)
 * function sm_door_server_create, as well as by itself.
 *
 * This thread needs to synchronize with the
 * main_servproc[SMEDIA_CNUM_OPEN_FD] door_call in terms of
 * both successful and failure scenarios.  main_servproc
 * locks dd_lock before calling door_create.  This thread
 * then attempts to lock, but will block until main_servproc
 * has either created all doors it requires, or until a
 * door_create has failed (door_create's return and the
 * creation of an associated thread are asynchronous).
 *
 * If door_create failed, this thread will be able to obtain
 * dd_lock and call pthread_exit.  If all door_create's succeed,
 * this thread will obtain dd_lock and commence with
 * customizing the thread's attributes.  door_bind is called to
 * bind this thread to the per-door private thread pool, and
 * main_servproc is cond_signal'd to avail it of this fact.
 *
 * Finally, this thread calls door_return, which causes it to
 * commence its lifetime as a server-side thread in implementation
 * of a Client Door door_call.
 */
static void *
sm_server_thread(void *arg)
{
	door_data_t	*door_dp;
	struct		sigaction act;
	int		i;
	int		err;

	door_dp = (door_data_t *)arg;

	if (door_dp == NULL) {
		fatal("sm_server_thread[%d]: argument is NULL!!\n",
		    pthread_self());
		exit(-1);
	}

	/* Wait for Client Door to be created */
	(void) mutex_lock(&door_dp->dd_lock);
	if (door_dp->dd_cdoor_descriptor < 0) {
		debug(5, "sm_server_thread[%d]: door_create() failed",
		    pthread_self());
		(void) mutex_unlock(&door_dp->dd_lock);
		pthread_exit((void *)-2);
	}
	(void) mutex_unlock(&door_dp->dd_lock);

	for (i = 0; i < N_BADSIGS; i++) {
		act.sa_sigaction = server_badsig_handler;
		(void) sigemptyset(&act.sa_mask);
		act.sa_flags = SA_SIGINFO;
		if (sigaction(badsigs[i], &act, NULL) == -1)
			warning(gettext(SIGACT_FAILED), strsignal(badsigs[i]),
			    strerror(errno));
	}
	if (sigemptyset(&door_dp->dd_newset) != 0)
		warning(gettext("sigemptyset failed. errno = %d\n"),
		    errno);
	if ((err = pthread_sigmask(SIG_BLOCK, &door_dp->dd_newset, NULL)) != 0)
		warning(gettext("pthread_sigmask failed = %d\n"), err);

	/* Bind thread with pool associated with Client Door */

	if (door_bind(door_dp->dd_cdoor_descriptor) < 0) {
		fatal("door_bind");
		exit(-1);
	}
	debug(5, "thr[%d] bound to Client Door[%d]", pthread_self(),
	    door_dp->dd_cdoor_descriptor);

	/*
	 * Set these two cancellation(5) attributes.  Ensure that the
	 * pthread we create has cancellation(5) DISABLED and DEFERRED,
	 * as our implementation is based on this.  DEFERRED is the
	 * default, but set it anyways, in case the defaults change in
	 * the future.
	 */
	if ((err = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL)) != 0)
		warning(gettext("pthread_setcancelstate(PTHREAD_CANCEL_DISABLE)"
		    " failed = %d\n"), err);
	if ((err = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,
	    NULL)) != 0)
		warning(gettext("pthread_setcanceltype(DEFERRED) "
		    "failed = %d\n"), err);

	/* Inform main_servproc that door_bind() is complete. */
	(void) cond_signal(&door_dp->dd_cv_bind);

	/*
	 * Per doors protocol, transfer control to the doors-runtime in
	 * order to make this thread available to answer future door_call()'s.
	 */
	(void) door_return(NULL, 0, NULL, 0);
	return (NULL);
}

/*
 * This function cleans up all per-connection resources.
 *
 * This function is called when the Client Door's service procedure
 * (client_servproc) is called w/ DOOR_UNREF_DATA, which is the
 * doors protocol convention stating that the number of file
 * descriptors referring to this door has dropped to one.
 * client_servproc is passed DOOR_UNREF_DATA because the Client Door
 * was door_create'd with the DOOR_UNREF bitflag.
 */
static void
cleanup(door_data_t *door_dp)
{
	/* do door_revoke() of Death Door */
	if (door_dp->dd_ddoor_descriptor >= 0) {
		debug(1, "cleanup[%d]: door_revoke() Death Door[%d]",
		    pthread_self(), door_dp->dd_ddoor_descriptor);

		if (door_revoke(door_dp->dd_ddoor_descriptor) < 0) {
			warning(gettext("cleanup[%d]: door_revoke() of Death "
			    "Door(%d) failed = %d"), pthread_self(),
			    door_dp->dd_ddoor_descriptor, errno);
		} else {
			door_dp->dd_ddoor_descriptor = -1;
		}
	}

	/* release memory that is shared between client and (our) server */
	if (door_dp->dd_buffd >= 0) {
		debug(1, "cleanup[%d]: release shared memory", pthread_self());
		(void) munmap(door_dp->dd_buf, door_dp->dd_buf_len);
		(void) close(door_dp->dd_buffd);

		door_dp->dd_buffd = -1;
		door_dp->dd_buf = NULL;
		door_dp->dd_buf_len = 0;
	}

	/* close the (target) device that the Client is operating on */
	if (door_dp->dd_fd >= 0) {
		debug(1, "cleanup[%d]: close(%d) target device", pthread_self(),
		    door_dp->dd_fd);
		if (close(door_dp->dd_fd) < 0) {
			warning(gettext("cleanup[%d]: close() of target device"
			    "failed = %d\n"), pthread_self(), errno);
		}
	}

	/*
	 * Unbind the current thread from the Client Door's private
	 * thread pool.
	 */
	debug(1, "cleanup[%d]: door_unbind() of Client Door[%d]",
	    pthread_self(), door_dp->dd_cdoor_descriptor);
	if (door_unbind() < 0)
		warning("door_unbind() of Client Door[%d] failed = "
		    "%d", door_dp->dd_cdoor_descriptor, errno);

	/* Disallow any future requests to the Client Door */
	if (door_dp->dd_cdoor_descriptor >= 0) {
		debug(1, "cleanup[%d]: door_revoke() Client Door[%d]",
		    pthread_self(), door_dp->dd_cdoor_descriptor);

		if (door_revoke(door_dp->dd_cdoor_descriptor) < 0) {
			warning(gettext("cleanup[%d]: door_revoke() of "
			    "Client Door[%d] failed = %d"), pthread_self(),
			    door_dp->dd_cdoor_descriptor, errno);
		}
	}

	free(door_dp);
	debug(5, "cleanup[%d] ...exiting\n", pthread_self());
}

/*
 * This is the door_server_create(3c) function used to customize
 * creation of the threads used in the handling of our daemon's
 * door_call(3c)'s.
 *
 * This function is called synchronously as part of door_create(3c).
 * Note that door_create(), however, is not synchronous; it can return
 * with the created door file descriptor before any associated
 * thread has been created.  As a result, synchronization is needed
 * between door_create() caller and the created pthread.  This is
 * needed both when each activity succeeds or when either activity
 * fails.
 *
 * Specifically, this function ensures that each "connection"
 * with the client creates only one thread in the per-door,
 * private thread pool.  This function locks dd_threadlock and
 * then calls pthread_create().  If that succeeds, dd_thread
 * is assigned the thread id, and dd_threadlock is unlocked.
 * Any per-connection door_create that causes control to flow
 * to this function will eventually find that dd_thread is
 * non-zero, and control will exit this function.
 *
 * In the current implementation, the door_create for the Client Door
 * is called first, and the Death Door is door_create'd second.
 * As a result, the following function can safely make the static
 * assumption that the first door (within a connection) is the
 * Client Door.  A connection's Client Door and Death Door share
 * the same thread as well as the same door_data_t instance.
 */
static void
sm_door_server_create(door_info_t *dip)
{
	door_data_t	*door_dp;
	pthread_t	tid;
	pthread_attr_t	attr;
	int		ret_val;
	int		err;

	if (dip == NULL) {
		return;
	}
	door_dp = (door_data_t *)(uintptr_t)dip->di_data;

	debug(10, "sm_door_server_create[%d]: entering...\n", pthread_self());

	/* create one thread for this door */

	(void) mutex_lock(&door_dp->dd_threadlock);

	if (door_dp->dd_thread != 0) {
		debug(8, "sm_door_server_create[%d]: Exiting without creating "
		    "thread.\n", pthread_self());
		(void) mutex_unlock(&door_dp->dd_threadlock);
		return;
	}

	(void) pthread_attr_init(&attr);

	if ((err = pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM)) != 0)
		warning(gettext("pthread_attr_setscope failed = %d\n"), err);
	if ((err = pthread_attr_setdetachstate(&attr,
	    PTHREAD_CREATE_DETACHED)) != 0)
		warning(gettext("pthread_attr_setdetachstate failed = %d\n"),
		    err);

	ret_val = pthread_create(&tid, &attr, sm_server_thread,
	    (void *)(uintptr_t)(dip->di_data));
	if (ret_val != 0) {
		warning(gettext("sm_door_server_create[%d]: pthread_create "
		    "failed = %d\n"), pthread_self(), ret_val);
		(void) mutex_unlock(&door_dp->dd_threadlock);
		(void) pthread_attr_destroy(&attr);
		return;
	}
	(void) pthread_attr_destroy(&attr);
	door_dp->dd_thread = tid;

	(void) mutex_unlock(&door_dp->dd_threadlock);
	debug(5, "Exiting sm_door_server_create[%d] after creating thr[%d].\n",
	    pthread_self(), tid);
}

static void
door_ret_err(smedia_reterror_t *reterror, int32_t err)
{
	reterror->cnum = SMEDIA_CNUM_ERROR;
	reterror->errnum = err;
	(void) door_return((char *)reterror, sizeof (smedia_reterror_t), 0, 0);
}

static void
my_door_return(char *data_ptr, size_t data_size,
	door_desc_t *desc_ptr, uint_t num_desc)
{
	(void) door_return(data_ptr, data_size, desc_ptr, num_desc);
}

static int32_t
raw_read(door_data_t *door_dp, smedia_services_t *req)
{
	struct uscsi_cmd	ucmd;
	union scsi_cdb		cdb;
	int32_t			ret_val;
	int32_t			num_sectors, sector_size;
	int32_t			rc_data[2];
	char			rq_data[RQ_LEN];

	(void) memset((void *) &rc_data, 0, sizeof (rc_data));
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (union scsi_cdb));

	if (door_dp->dd_sector_size == 0) {
		sector_size = get_sector_size(door_dp->dd_fd);
		door_dp->dd_sector_size = sector_size;
	} else sector_size = door_dp->dd_sector_size;

	if ((req->reqraw_read.nbytes > door_dp->dd_buf_len) ||
		(door_dp->dd_buf == NULL)) {
		errno = EINVAL;
		return (-1);
	}
	if ((!req->reqraw_read.nbytes) ||
		(req->reqraw_read.nbytes % sector_size)) {
		errno = EINVAL;
		return (-1);
	}

	(void) memset((void *) &cdb, 0, sizeof (cdb));
	num_sectors = (uint32_t)req->reqraw_read.nbytes/sector_size;

	cdb.scc_cmd = SCMD_READ_G1;
	FORMG1ADDR(&cdb, (uint32_t)req->reqraw_read.blockno);
	FORMG1COUNT(&cdb, num_sectors);

	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP1;
	ucmd.uscsi_bufaddr = (caddr_t)door_dp->dd_buf;
	ucmd.uscsi_buflen = (uint32_t)req->reqraw_read.nbytes;
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	ret_val = do_uscsi_cmd(door_dp->dd_fd,
		&ucmd, USCSI_READ|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "read failed: %d - %d errno = %d\n",
			ret_val, ucmd.uscsi_status, errno);
		debug(5, "buflen = 0x%x resid = 0x%x sector size = %d\n",
			ucmd.uscsi_buflen, ucmd.uscsi_resid, sector_size);
		debug(5, "cdb addr: %x %x %x %x \n", cdb.g1_addr3,
			cdb.g1_addr2, cdb.g1_addr1, cdb.g1_addr0);
		debug(5, "cdb count: %x %x\n", cdb.g1_count1,
			cdb.g1_count0);
		return (-1);
	}
	ret_val = ucmd.uscsi_buflen - ucmd.uscsi_resid;
	return (ret_val);
}

static int32_t
raw_write(door_data_t *door_dp, smedia_services_t *req)
{
	struct uscsi_cmd	ucmd;
	union scsi_cdb		cdb;
	int32_t			ret_val;
	int32_t			num_sectors, sector_size;
	int32_t			rc_data[2];
	char			rq_data[RQ_LEN];

	(void) memset((void *) &rc_data, 0, sizeof (rc_data));
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (union scsi_cdb));

	if (door_dp->dd_sector_size == 0) {
		sector_size = get_sector_size(door_dp->dd_fd);
		door_dp->dd_sector_size = sector_size;
	} else sector_size = door_dp->dd_sector_size;


	if ((req->reqraw_write.nbytes > door_dp->dd_buf_len) ||
		(door_dp->dd_buf == NULL)) {
		errno = EINVAL;
		return (-1);
	}
	if ((req->reqraw_write.nbytes % sector_size)) {
		errno = EINVAL;
		return (-1);
	}

	(void) memset((void *) &cdb, 0, sizeof (cdb));
	num_sectors = (uint32_t)req->reqraw_write.nbytes/sector_size;

	cdb.scc_cmd = SCMD_WRITE_G1;
	FORMG1ADDR(&cdb, (uint32_t)req->reqraw_write.blockno);
	FORMG1COUNT(&cdb, num_sectors);

	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP1;
	ucmd.uscsi_bufaddr = (caddr_t)door_dp->dd_buf;
	ucmd.uscsi_buflen = (uint32_t)req->reqraw_write.nbytes;
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	ret_val = do_uscsi_cmd(door_dp->dd_fd,
		&ucmd, USCSI_WRITE|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "write failed: %d - %d errno = %d\n",
			ret_val, ucmd.uscsi_status, errno);
		debug(5, "buflen = 0x%x resid = 0x%x sector size = %d\n",
			ucmd.uscsi_buflen, ucmd.uscsi_resid, sector_size);
		debug(5, "cdb addr: %x %x %x %x \n", cdb.g1_addr3,
			cdb.g1_addr2, cdb.g1_addr1, cdb.g1_addr0);
		debug(5, "cdb count: %x %x\n", cdb.g1_count1,
			cdb.g1_count0);
		return (-1);
	}
	ret_val = ucmd.uscsi_buflen - ucmd.uscsi_resid;
	return (ret_val);
}

static int32_t
set_protection_status(door_data_t *door_dp, smedia_services_t *req)
{
	int32_t			ret_val, saved_errno, status;
	struct scsi_inquiry	inq;
	char			vid[9];
	char			pid[17];
	struct passwd		*pwd;
	char			uname[MAXUGNAME + 1];
	char			*new_state, *old_state;

	/*
	 * Read the current protection state before modifiying.
	 * Needed for audit purposes.
	 */
	switch (get_device_type_scsi(door_dp->dd_fd, &inq)) {
	case SCSI_IOMEGA:
		status = scsi_zip_media_status(door_dp->dd_fd);
		ret_val = scsi_zip_write_protect(door_dp->dd_fd,
			&req->reqset_protection_status.prot_state);
		break;
	case SCSI_FLOPPY:
		info("Formatting floppy");
		status = scsi_floppy_media_status(door_dp->dd_fd);
		ret_val = scsi_floppy_write_protect(door_dp->dd_fd,
			&req->reqset_protection_status.prot_state);
		break;
	case SCSI_GENERIC:
		status = scsi_media_status(door_dp->dd_fd);
		ret_val = scsi_write_protect(door_dp->dd_fd,
			&req->reqset_protection_status.prot_state);
		break;
	}

	saved_errno = errno;
	new_state = xlate_state(
	    req->reqset_protection_status.prot_state.sm_new_state);
	old_state = xlate_state(status);

	if (can_audit()) {
		(void) audit_save_me(door_dp);
		door_dp->audit_text[0] = 0;
		door_dp->audit_text1[0] = 0;
		door_dp->audit_event = AUE_smserverd;
	}
	(void) strlcpy(vid, inq.inq_vid, sizeof (vid));
	(void) strlcpy(pid, inq.inq_pid, sizeof (pid));
	if (ret_val < 0) {
	    if (errno == EACCES) {
		pwd = getpwuid(door_dp->dd_cred.dc_ruid);
		if (pwd != NULL) {
			(void) strlcpy(uname,
				pwd->pw_name, MAXUGNAME);
		} else uname[0] = 0;

		if (can_audit()) {
			(void) snprintf(door_dp->audit_text,
				sizeof (door_dp->audit_text),
				dgettext(TEXT_DOMAIN, "from %s to %s"),
				old_state, new_state);

			(void) snprintf(door_dp->audit_text1,
				sizeof (door_dp->audit_text1),
				"%s %s (%d,%d)", vid, pid,
				(int)major(door_dp->dd_stat.st_rdev),
				(int)minor(door_dp->dd_stat.st_rdev));

			door_dp->audit_sorf = 1;
			if (audit_audit(door_dp) == -1)
			    warning("Error in writing audit info\n");
		}
	    } /* errno == EACCES */
	    errno = saved_errno;
	    return (-1);
	}
	if (can_audit()) {
		(void) snprintf(door_dp->audit_text,
			sizeof (door_dp->audit_text),
			dgettext(TEXT_DOMAIN, "from %s to %s"),
			old_state, new_state);

		(void) snprintf(door_dp->audit_text1,
			sizeof (door_dp->audit_text1),
			"%s %s (%d,%d)", vid, pid,
			(int)major(door_dp->dd_stat.st_rdev),
			(int)minor(door_dp->dd_stat.st_rdev));

		door_dp->audit_sorf = 0;
		if (audit_audit(door_dp) == -1)
		    warning("Error in writing audit info\n");
	}
	errno = saved_errno;
	return (0);
}

static int32_t
set_shfd(door_data_t *door_dp, int32_t fd, smedia_services_t *req)
{
	void	*fbuf;
	int32_t ret_val = 0;

	if ((door_dp->dd_buffd != -1) && (door_dp->dd_buf != NULL)) {
		ret_val = munmap(door_dp->dd_buf, door_dp->dd_buf_len);
		if (ret_val == -1)
			warning(gettext("munmap failed. errno=%d\n"),
			    errno);
		(void) close(door_dp->dd_buffd);

		door_dp->dd_buffd = -1;
		door_dp->dd_buf = 0;
		door_dp->dd_buf_len = 0;
	}

	fbuf = mmap(0, req->reqset_shfd.fdbuf_len,
	    PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
	if (fbuf == MAP_FAILED) {
		ret_val = errno;
		debug(5, "mmap failed. errno=%d\n", errno);
		return (ret_val);
	}
	door_dp->dd_buffd = fd;
	door_dp->dd_buf = fbuf;
	door_dp->dd_buf_len = req->reqset_shfd.fdbuf_len;

	return (0);
}

static int32_t
reassign_block(door_data_t *door_dp, smedia_services_t *req)
{
	struct uscsi_cmd	ucmd;
	union scsi_cdb		cdb;
	int32_t			ret_val;
	int32_t			sector_size;
	char			*read_buf;
	uchar_t			mode_data[MD_LEN];

	if (get_mode_page(door_dp->dd_fd, 0, 1,
	    mode_data, MD_LEN) < 0) {
		debug(5, "Mode sense failed\n");
		ret_val =  scsi_reassign_block(door_dp->dd_fd,
		    req->reqreassign_block.blockno);
		if (ret_val != 0)
			return (-1);
		return (0);
	}

	/*
	 * No need to check if enough data is returned for
	 * AWRE bit or not.
	 * It will be 0 otherwise which needs to reassign the block.
	 */
	if (!(mode_data[AWRE_OFFSET] & AWRE)) {
		debug(5, "AWRE bit not set\n");
		ret_val =  scsi_reassign_block(door_dp->dd_fd,
			req->reqreassign_block.blockno);
		if (ret_val != 0)
			return (-1);
		return (0);
	}
	sector_size = (mode_data[BLOCK_LEN_OFFSET] << 16) |
		(mode_data[BLOCK_LEN_OFFSET + 1] << 8) |
		mode_data[BLOCK_LEN_OFFSET + 2];

	debug(5, "REASSIGN BLOCK: sec size = 0x%x\n", sector_size);
	read_buf = (char *)malloc(sector_size);
	if (read_buf == NULL) {
		/* Alloc failed. Atleast reassign the block */
		ret_val =  scsi_reassign_block(door_dp->dd_fd,
			req->reqreassign_block.blockno);
		if (ret_val != 0)
			return (-1);
		return (0);
	}

	(void) memset(read_buf, 0, sector_size);
	/* Read the sector */
	debug(5, "Reading the block %d\n",
		(uint32_t)req->reqreassign_block.blockno);

	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (union scsi_cdb));

	cdb.scc_cmd = SCMD_READ_G1;
	FORMG1ADDR(&cdb, req->reqreassign_block.blockno);
	FORMG1COUNT(&cdb, 1);	/* One block */

	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP1;
	ucmd.uscsi_bufaddr = (caddr_t)read_buf;
	ucmd.uscsi_buflen = sector_size;
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	(void) do_uscsi_cmd(door_dp->dd_fd, &ucmd, USCSI_READ);

	/* Write the data back */

	debug(5, "Writing the block %d\n",
		(uint32_t)req->reqreassign_block.blockno);
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset((void *) &cdb, 0, sizeof (cdb));

	cdb.scc_cmd = SCMD_WRITE_G1;
	FORMG1ADDR(&cdb, req->reqreassign_block.blockno);
	FORMG1COUNT(&cdb, 1);	/* One block */

	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP1;
	ucmd.uscsi_bufaddr = (caddr_t)read_buf;
	ucmd.uscsi_buflen = sector_size;
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ret_val = do_uscsi_cmd(door_dp->dd_fd, &ucmd, USCSI_WRITE);
	free(read_buf);
	if (ret_val || ucmd.uscsi_status) {
		debug(5, "Reassign failed: %d - %d errno = %d\n",
			ret_val, ucmd.uscsi_status, errno);
		ret_val = scsi_reassign_block(door_dp->dd_fd,
			req->reqreassign_block.blockno);
		if (ret_val != 0)
			return (-1);
		return (0);
	}

	return (0);
}

static void
close_door_descs(door_desc_t *dp, uint_t ndesc)
{
	while (ndesc > 0) {
		int fd = dp->d_data.d_desc.d_descriptor;
		if (dp->d_attributes & DOOR_DESCRIPTOR)
			(void) close(fd);
		dp++;
		ndesc--;
	}
}

/*
 * This is a Death Door's service procedure.
 *
 * This procedure is a NOP because the Death Door functionality
 * is no longer used and will be removed in the future.
 */
/*ARGSUSED*/
static void
death_servproc(void *cookie, char *argp, size_t arg_size,
    door_desc_t *dp, uint_t ndesc)
{
	debug(1, "death_servproc[%d]: argp = 0x%p  "
	    "Death Door[%d]\n", pthread_self(), (void *)argp,
	    ((door_data_t *)cookie)->dd_ddoor_descriptor);

	(void) door_return(NULL, 0, NULL, 0);
}

/*
 * This is a Client Door's service procedure.
 *
 * This procedure is specified in the door_create() of a Client Door,
 * and its functionality represents the bulk of services that the
 * rpc.smserverd daemon offers.
 */
static void
client_servproc(void *cookie, char *argp, size_t arg_size,
    door_desc_t *dp, uint_t ndesc)
{
	smedia_services_t	*req;
	smedia_services_t	rmsvc;
	smedia_reterror_t	reterror;
	smedia_retraw_read_t	retraw_read;
	struct scsi_inquiry	inq;
	struct dk_minfo		media_info;
	struct dk_geom		dkgeom;
	int32_t			status;
	uchar_t			data[18];
	int32_t			completed = 0;
	door_data_t		*door_dp;
	size_t			retbuf_size;
	struct uscsi_cmd	ucmd;
	union scsi_cdb		cdb;
	int32_t			ret_val, err;
	char			rq_data[RQ_LEN];
	uint_t			nexpected_desc;
	struct vtoc		vtoc;

	door_dp = (door_data_t *)cookie;
	req = (smedia_services_t *)((void *)argp);

	debug(10, "client_servproc[%d]...\n", pthread_self());

	if (argp == DOOR_UNREF_DATA) {
		debug(5, "client_servproc[%d]: req = DOOR_UNREF_DATA\n",
		    pthread_self());
		debug(5, "Client has exited. Cleaning up resources\n");

		(void) mutex_lock(&svcstate_lock);
		svccount--;
		(void) mutex_unlock(&svcstate_lock);

		cleanup(door_dp);
		return;
	}

	(void) mutex_lock(&svcstate_lock);
	svcstate = _SERVED;
	(void) mutex_unlock(&svcstate_lock);

	rmsvc.in.cnum = req->in.cnum;
	debug(5, "client_servproc[%d]: req = %s\n", pthread_self(),
	    xlate_cnum(req->in.cnum));

	/*
	 * Our caller may have passed more descriptors than we expected.
	 * If so, we silently close (and ignore) them.
	 */
	nexpected_desc = (req->in.cnum == SMEDIA_CNUM_SET_SHFD) ? 1 : 0;
	if (ndesc > nexpected_desc) {
		close_door_descs(dp + nexpected_desc, ndesc - nexpected_desc);
	}

	switch (req->in.cnum) {
	default:
		debug(5, "client_servproc: unknown command %d\n", req->in.cnum);
		door_ret_err(&reterror, ENOTSUP);
		break;

	case SMEDIA_CNUM_SET_SHFD:
		if (ndesc == 0)
			door_ret_err(&reterror, EINVAL);
		/*
		 * Allocate shared memory for this connection.
		 * If this connection already has shared memory,
		 * deallocate before doing the allocation.
		 */
		ret_val = set_shfd(door_dp, dp->d_data.d_desc.d_descriptor,
		    req);
		if (ret_val == 0) {
			reterror.cnum = SMEDIA_CNUM_SET_SHFD;
			reterror.errnum = 0;

			my_door_return((char *)&reterror,
				sizeof (smedia_reterror_t), 0, 0);
		} else {
			(void) close(dp->d_data.d_desc.d_descriptor);
			door_ret_err(&reterror, ret_val);
		}
		break;

	case SMEDIA_CNUM_RAW_READ:
		debug(10, " arg size = %d blk num=0x%x nbytes = 0x%x \n",
			(int)arg_size,
			(uint32_t)req->reqraw_read.blockno,
			req->reqraw_read.nbytes);
		retbuf_size = sizeof (smedia_retraw_read_t);
		if (req->reqraw_read.nbytes == 0) {
			/* Nothing to write */
			rmsvc.retraw_write.nbytes = 0;
			my_door_return((char *)&rmsvc,
				sizeof (smedia_retraw_write_t), 0, 0);
		}
		retraw_read.cnum = SMEDIA_CNUM_RAW_READ;
		ret_val = raw_read(door_dp, req);
		if (ret_val == -1) {
			door_ret_err(&reterror, errno);
		}
		retraw_read.nbytes = ret_val;
		my_door_return((char *)&retraw_read, retbuf_size, 0, 0);
		break;

	case	SMEDIA_CNUM_USCSI_CMD:
		retbuf_size = sizeof (smedia_retuscsi_cmd_t);
		rmsvc.retuscsi_cmd.cnum = SMEDIA_CNUM_USCSI_CMD;
		ucmd.uscsi_flags = req->requscsi_cmd.uscsi_flags;
		ucmd.uscsi_cdb = (caddr_t)&req->requscsi_cmd.uscsi_cdb;
		ucmd.uscsi_cdblen = req->requscsi_cmd.uscsi_cdblen;
		ucmd.uscsi_bufaddr = (caddr_t)door_dp->dd_buf;
		ucmd.uscsi_buflen = req->requscsi_cmd.uscsi_buflen;
		ucmd.uscsi_timeout = req->requscsi_cmd.uscsi_timeout;
		ucmd.uscsi_rqlen = req->requscsi_cmd.uscsi_rqlen;
		ucmd.uscsi_rqbuf = (caddr_t)&rmsvc.retuscsi_cmd.uscsi_rqbuf;
		debug(5, "USCSI CMD 0x%x requested.\n",
		    req->requscsi_cmd.uscsi_cdb[0]);
		/*
		 * Check the device type and invalid flags specified.
		 * We permit operations only on CDROM devices types.
		 */
		errno = invalid_uscsi_operation(door_dp, &ucmd);
		if (errno) {
			door_ret_err(&reterror, errno);
		}

		if ((req->requscsi_cmd.uscsi_buflen) &&
		    ((req->requscsi_cmd.uscsi_buflen > door_dp->dd_buf_len) ||
		    (door_dp->dd_buf == NULL))) {
			debug(5, "uscsi_cmd failed: uscsi_buflen=0x%x "
			    "dd_buf_len=0x%x dd_buf=0x%p\n",
			    req->requscsi_cmd.uscsi_buflen,
			    door_dp->dd_buf_len,
			    door_dp->dd_buf);
			errno = EINVAL;
			door_ret_err(&reterror, errno);
		}
		ret_val = do_uscsi_cmd(door_dp->dd_fd,
			&ucmd, req->requscsi_cmd.uscsi_flags);
		rmsvc.retuscsi_cmd.uscsi_status = ucmd.uscsi_status;
		rmsvc.retuscsi_cmd.uscsi_resid = ucmd.uscsi_resid;
		rmsvc.retuscsi_cmd.uscsi_rqstatus = ucmd.uscsi_rqstatus;
		rmsvc.retuscsi_cmd.uscsi_rqresid = ucmd.uscsi_rqresid;
		rmsvc.retuscsi_cmd.uscsi_retval = ret_val;
		rmsvc.retuscsi_cmd.uscsi_errno = errno;
		if (ret_val || ucmd.uscsi_status) {
			debug(5, "uscsi_cmd failed: %d - %d errno = %d\n",
				ret_val, ucmd.uscsi_status, errno);
		}
		my_door_return((char *)&rmsvc, retbuf_size, 0, 0);
		break;

	case SMEDIA_CNUM_RAW_WRITE:
		if (req->reqraw_write.nbytes == 0) {
			/* Nothing to write */
			rmsvc.retraw_write.nbytes = 0;
			my_door_return((char *)&rmsvc,
				sizeof (smedia_retraw_write_t), 0, 0);
		}
		ret_val = raw_write(door_dp, req);
		if (ret_val == -1)
			door_ret_err(&reterror, errno);
		rmsvc.retraw_write.nbytes = ret_val;
		my_door_return((char *)&rmsvc, sizeof (smedia_retraw_write_t),
			0, 0);
		break;

	case SMEDIA_CNUM_GET_DEVICE_INFO:

		(void) memset((void *) &inq, 0, sizeof (inq));
		(void) memset((void *) &ucmd, 0, sizeof (ucmd));
		(void) memset((void *) &cdb, 0, sizeof (union scsi_cdb));
		cdb.scc_cmd = SCMD_INQUIRY;
		FORMG0COUNT(&cdb, sizeof (inq));
		ucmd.uscsi_cdb = (caddr_t)&cdb;
		ucmd.uscsi_cdblen = CDB_GROUP0;
		ucmd.uscsi_bufaddr = (caddr_t)&inq;
		ucmd.uscsi_buflen = sizeof (inq);
		ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
		ucmd.uscsi_rqlen = RQ_LEN;
		ucmd.uscsi_rqbuf = rq_data;
		ret_val = do_uscsi_cmd(door_dp->dd_fd,
			&ucmd, USCSI_READ|USCSI_RQENABLE);
		if (ret_val || ucmd.uscsi_status) {
			debug(5, "inquiry failed: %d - %d errno = %d\n",
				ret_val, ucmd.uscsi_status, errno);
			door_ret_err(&reterror, errno);
		}

		debug(5, "%s\n", inq.inq_vid);
		debug(5, "%s\n", rmsvc.retget_device_info.sm_vendor_name);

		(void) strlcpy(rmsvc.retget_device_info.sm_vendor_name,
			inq.inq_vid, 8);
		rmsvc.retget_device_info.sm_vendor_name[8] = 0;
		(void) strlcpy(rmsvc.retget_device_info.sm_product_name,
			inq.inq_pid, 16);
		rmsvc.retget_device_info.sm_product_name[16] = 0;
		(void) strlcpy(rmsvc.retget_device_info.sm_firmware_version,
			inq.inq_revision, 4);
		rmsvc.retget_device_info.sm_firmware_version[4] = ' ';
		(void) strlcpy(
			&rmsvc.retget_device_info.sm_firmware_version[5],
				inq.inq_serial, 12);
		rmsvc.retget_device_info.sm_product_name[17] = 0;

		rmsvc.retget_device_info.sm_interface_type = IF_SCSI;

		debug(5, "Vendor name = %s\n",
		    rmsvc.retget_device_info.sm_vendor_name);
		debug(5, "product name = %s\n",
		    rmsvc.retget_device_info.sm_product_name);
		debug(5, "Firmware revision = %s\n",
		    rmsvc.retget_device_info.sm_firmware_version);

		my_door_return((char *)&rmsvc.retget_device_info,
			sizeof (smedia_retget_device_info_t), 0, 0);
		break;

	case	SMEDIA_CNUM_GET_MEDIUM_PROPERTY:

		(void) memset((void *)&rmsvc.retget_medium_property.smprop,
			0, sizeof (smmedium_prop_t));

		ret_val = ioctl(door_dp->dd_fd, DKIOCGMEDIAINFO, &media_info);

		if (ret_val < 0) {
			uint32_t capacity;
			uint32_t blocksize;
			/*
			 * Devices may fail DKIOCGMEDIAINFO if an unformed
			 * media is inserted. We can get the capacity
			 * information from the SCMD_READ_FORMAT_CAP command.
			 */

			debug(5, "DKIOCGMEDIAINFO failed; using "
			    "SCMD_READ_FORMAT_CAP");
			ret_val = get_media_capacity(door_dp->dd_fd,
			    &capacity, &blocksize);

			if (ret_val >= 0) {
				media_info.dki_lbsize =	blocksize;
				media_info.dki_capacity = capacity;
			} else {
				debug(5, "SCMD_READ_FORMAT_CAP failed");
				door_ret_err(&reterror, errno);
			}
		}
		rmsvc.retget_medium_property.smprop.sm_blocksize =
		    media_info.dki_lbsize;
		rmsvc.retget_medium_property.smprop.sm_capacity =
		    media_info.dki_capacity;

		rmsvc.retget_medium_property.smprop.sm_media_type =
		    media_info.dki_media_type;
		/*
		 * These devices show as SCSI devices but we need to treat it
		 * differently. so we need a seperate class.
		 */
		if (get_device_type_scsi(door_dp->dd_fd, &inq) == SCSI_FLOPPY) {
			rmsvc.retget_medium_property.smprop.sm_media_type =
			    SM_SCSI_FLOPPY;
		}

		/* Check for EFI type because DKIOCGGEOM does not support EFI */
		ret_val = ioctl(door_dp->dd_fd, DKIOCGVTOC, &vtoc);
		if (!((ret_val < 0) && (errno == ENOTSUP))) {
			ret_val = ioctl(door_dp->dd_fd, DKIOCGGEOM, &dkgeom);
			if (ret_val < 0)  {
				/*
				 * DKIOCGGEOM may fail for unformed floppies.
				 * We need to generate the appropriate geometry
				 * information.
				 */
				if (rmsvc.retget_medium_property.smprop.
				    sm_media_type == SM_SCSI_FLOPPY) {
					ret_val = get_floppy_geom(
					    door_dp->dd_fd,
					    media_info.dki_capacity, &dkgeom);

					if (ret_val < 0) {
						debug(5, "Cannot determine "
						    "media size");
						door_ret_err(&reterror, errno);
					}
				} else {
#ifdef sparc
					debug(5, "DKIOCGGEOM ioctl failed");
					door_ret_err(&reterror, errno);
#else /* !sparc */
					/*
					 * Try getting Physical geometry on x86.
					 */
					ret_val = ioctl(door_dp->dd_fd,
					    DKIOCG_PHYGEOM, &dkgeom);
					if (ret_val < 0) {
						debug(5, "DKIOCG_PHYGEOM "
						    "ioctl failed");
						door_ret_err(&reterror, errno);
					}
#endif /* sparc */
				}
			}


			/*
			 * Some faked geometry may not have pcyl filled in so
			 * later calculations using this field will be
			 * incorrect.  We will substitute it with the number of
			 * available cylinders.
			 */
			if (dkgeom.dkg_pcyl == 0)
				rmsvc.retget_medium_property.smprop.sm_pcyl =
				    dkgeom.dkg_ncyl;
			else
				rmsvc.retget_medium_property.smprop.sm_pcyl =
				    dkgeom.dkg_pcyl;

			rmsvc.retget_medium_property.smprop.sm_nhead =
			    dkgeom.dkg_nhead;
			rmsvc.retget_medium_property.smprop.sm_nsect =
			    dkgeom.dkg_nsect;
		}

		debug(1, "properties are: lbasize = %d, cap = %llu",
		    media_info.dki_lbsize, media_info.dki_capacity);

		my_door_return((char *)&rmsvc.retget_medium_property,
			sizeof (smedia_retget_medium_property_t), 0, 0);
		break;

	case	SMEDIA_CNUM_GET_PROTECTION_STATUS:
		switch (get_device_type_scsi(door_dp->dd_fd, &inq)) {
		case SCSI_FLOPPY:
			status = scsi_floppy_media_status(door_dp->dd_fd);
			break;
		case SCSI_IOMEGA:
			status = scsi_zip_media_status(door_dp->dd_fd);
			break;
		case SCSI_GENERIC:
			status = scsi_media_status(door_dp->dd_fd);
			break;
		default:
			door_ret_err(&reterror, errno);
		}
		if (status < 0)
			door_ret_err(&reterror, errno);

		rmsvc.retget_protection_status.prot_state.sm_new_state  =
			status;

		my_door_return((char *)&rmsvc.retget_protection_status,
			sizeof (smedia_retget_protection_status_t), 0, 0);
		break;

	case	SMEDIA_CNUM_SET_PROTECTION_STATUS:

		ret_val = set_protection_status(door_dp, req);
		if (ret_val == -1)
			door_ret_err(&reterror, errno);
		else
			my_door_return((char *)&rmsvc.retset_protection_status,
				sizeof (smedia_retset_protection_status_t),
				0, 0);
		break;

	case SMEDIA_CNUM_FORMAT:
		switch (get_device_type_scsi(door_dp->dd_fd, &inq)) {
		case SCSI_FLOPPY:
			info("formatting floppy");
			err = scsi_floppy_format(door_dp->dd_fd,
				req->reqformat.flavor, req->reqformat.mode);

			break;
		case SCSI_IOMEGA:
			err = scsi_zip_format(door_dp->dd_fd,
				req->reqformat.flavor, req->reqformat.mode);
			break;
		case SCSI_GENERIC:
			err = scsi_format(door_dp->dd_fd,
				req->reqformat.flavor, req->reqformat.mode);
			break;
		default:
			door_ret_err(&reterror, ENOTSUP);
		}

		if (err)
			door_ret_err(&reterror, errno);
		my_door_return((char *)&rmsvc.retformat,
			sizeof (smedia_retformat_t), 0, 0);

		break;

	case SMEDIA_CNUM_CHECK_FORMAT_STATUS:

		(void) memset((void *) &cdb, 0, sizeof (union scsi_cdb));
		(void) memset((void *) &ucmd, 0, sizeof (ucmd));
		(void) memset((void *) &data, 0, sizeof (data));
		cdb.scc_cmd = SCMD_REQUEST_SENSE;
		cdb.g0_count0 = sizeof (data);
		ucmd.uscsi_cdb = (caddr_t)&cdb;
		ucmd.uscsi_cdblen = CDB_GROUP0;
		ucmd.uscsi_bufaddr = (caddr_t)&data;
		ucmd.uscsi_buflen = sizeof (data);
		ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
		ucmd.uscsi_rqlen = RQ_LEN;
		ucmd.uscsi_rqbuf = rq_data;
		ret_val = do_uscsi_cmd(door_dp->dd_fd,
			&ucmd, USCSI_READ|USCSI_RQENABLE);
		if (ret_val || ucmd.uscsi_status) {
			debug(5, "Request sense failed: %d - %d errno = %d\n",
				ret_val, ucmd.uscsi_status, errno);
			door_ret_err(&reterror, errno);
		}

		if ((data[0] & 0x7F) == DEFERRED_ERROR) {
		/* Deffered error. The format must have failed */
			debug(5, "format failed!\n");
			door_ret_err(&reterror, EIO);
		}

		if (data[SKSV_OFFSET] & SKSV_FIELD) {
			completed =
				(data[FORMAT_PROGRESS_INDICATOR_OFFSET_0] << 8)
				| data[FORMAT_PROGRESS_INDICATOR_OFFSET_1];
			completed = (completed*100/65536);
		} else {
			completed = (100);
		}
		rmsvc.retcheck_format_status.percent_complete = completed;
		my_door_return((char *)&rmsvc.retcheck_format_status,
			sizeof (smedia_retcheck_format_status_t), 0, 0);
		break;

	case SMEDIA_CNUM_REASSIGN_BLOCK:

		ret_val = reassign_block(door_dp, req);
		if (ret_val == -1)
			door_ret_err(&reterror, errno);
		my_door_return((char *)&rmsvc.retreassign_block,
			sizeof (smedia_retreassign_block_t), 0, 0);
		break;

	}	/* end of switch */

	debug(10, "Exiting client server...\n");
	my_door_return((char *)&reterror, sizeof (smedia_reterror_t), 0, 0);
}

/*
 * This is the service procedure for the door that is associated with
 * the (doorfs) filesystem Door that is created at 'smedia_service'.
 */
/*ARGSUSED*/
static void
main_servproc(void *server_data, char *argp, size_t arg_size,
    door_desc_t *dp, uint_t ndesc)
{
	smedia_services_t	*req;
	door_cred_t	door_credentials;
	int		ret_val;
	door_data_t	*ddata;
	smedia_reterror_t	reterror;
	smedia_reterror_t	retok;
	struct	stat	stat;
	door_desc_t	*didpp;
	struct dk_cinfo dkinfo;
	uint_t		nexpected_desc;

	debug(10, "Entering main_servproc[%d].\n", pthread_self());

	didpp = dp;
	(void) mutex_lock(&svcstate_lock);
	svcstate = _SERVED;
	(void) mutex_unlock(&svcstate_lock);

	reterror.cnum = SMEDIA_CNUM_ERROR;
	reterror.errnum = SMEDIA_FAILURE;

	if (argp == NULL) {
		debug(5, "argp is NULL\n");
		if (ndesc > 0)
			close_door_descs(dp, ndesc);
		my_door_return((char *)&reterror,
		    sizeof (smedia_reterror_t), 0, 0);
	}

	req = (smedia_services_t *)((void *)argp);

	retok.cnum = req->in.cnum;
	retok.errnum = 0;

	debug(5, "req = %s arg_size = 0x%x \n",
	    xlate_cnum(req->reqopen.cnum), arg_size);

	/*
	 * Our caller may have passed more descriptors than we expected.
	 * If so, we silently close (and ignore) them.
	 */
	nexpected_desc = (req->in.cnum == SMEDIA_CNUM_OPEN_FD) ? 1 : 0;
	if (ndesc > nexpected_desc) {
		close_door_descs(dp + nexpected_desc, ndesc - nexpected_desc);
	}

	switch (req->in.cnum) {
	default:
		debug(5, "main_servproc: unknown command 0x%x\n",
		    req->reqopen.cnum);
		break;

	case SMEDIA_CNUM_PING:
		/*
		 * This service is to indicate that server is up and
		 * running. It is usually called from another instance of
		 * server that is started.
		 */
		reterror.cnum = SMEDIA_CNUM_PING;
		reterror.errnum = 0;
		my_door_return((char *)&reterror,
		    sizeof (smedia_reterror_t), 0, 0);
		break;


	case SMEDIA_CNUM_OPEN_FD:

		debug(5, "ndesc = %d\n", ndesc);
		if (ndesc == 0) {
			my_door_return((char *)&reterror,
			    sizeof (smedia_reterror_t), 0, 0);
		}
		debug(5, "Checking file descriptor of target device\n");
		if (fstat(didpp->d_data.d_desc.d_descriptor, &stat) < 0) {
			warning(gettext("main_servproc:fstat failed. "
			    "errno = %d\n"), errno);
			(void) close(didpp->d_data.d_desc.d_descriptor);
			my_door_return((char *)&reterror,
			    sizeof (smedia_reterror_t), 0, 0);
		}
		debug(5, "descriptor = %d st_mode = 0x%lx\n",
		    didpp->d_data.d_desc.d_descriptor,
		    stat.st_mode);

		/* Obtain the credentials of the user */
		ret_val = door_cred(&door_credentials);
		if (ret_val < 0) {
			warning(gettext("main_servproc:door_cred "
			    "failed. errno = %d\n"), errno);
			(void) close(didpp->d_data.d_desc.d_descriptor);
			my_door_return((char *)&reterror,
			    sizeof (smedia_reterror_t), 0, 0);
		}
		if (ioctl(didpp->d_data.d_desc.d_descriptor, DKIOCINFO,
			&dkinfo) == -1) {
			warning(gettext("main_servproc:DKIOCINFO failed. "
			    "errno = %d\n"), errno);
			(void) close(didpp->d_data.d_desc.d_descriptor);
			my_door_return((char *)&reterror,
			    sizeof (smedia_reterror_t), 0, 0);
		}

		ddata = (door_data_t *)calloc(1, sizeof (door_data_t));
		if (ddata == NULL) {
			warning(gettext("main_servproc:calloc failed. "
			    "errno = %d\n"), errno);
			(void) close(didpp->d_data.d_desc.d_descriptor);
			my_door_return((char *)&reterror,
			    sizeof (smedia_reterror_t), 0, 0);
		}
		ddata->dd_stat = stat;
		ddata->dd_cred = door_credentials;
		ddata->dd_fd = didpp->d_data.d_desc.d_descriptor;
		ddata->dd_buf = NULL;
		ddata->dd_buf_len = 0;
		ddata->dd_buffd = -1;
		ddata->dd_sector_size = 0;
		ddata->dd_dkinfo = dkinfo;
		debug(5, "ddata = 0x%p \n", (void *)ddata);

		/* specify a function that'll customize our door threads */
		(void) door_server_create(sm_door_server_create);
		debug(5, "door_server_create called.\n");

		(void) mutex_lock(&ddata->dd_lock);

		/* create Client Door */
		ddata->dd_cdoor_descriptor =
		    door_create(client_servproc,
		    (void *)ddata, DOOR_PRIVATE | DOOR_NO_CANCEL | DOOR_UNREF);

		if (ddata->dd_cdoor_descriptor < 0) {
			/* then door_create() failed */
			int err = errno;

			(void) mutex_unlock(&ddata->dd_lock);

			warning(gettext("main_servproc: door_create of Client "
			    "Door failed = %d\n"), err);
			free(ddata);

			/* close target device */
			(void) close(didpp->d_data.d_desc.d_descriptor);
			my_door_return((char *)&reterror,
			    sizeof (smedia_reterror_t), 0, 0);
		}

		/* create Death Door */
		ddata->dd_ddoor_descriptor =
		    door_create(death_servproc, (void *)ddata,
		    DOOR_REFUSE_DESC | DOOR_NO_CANCEL);
		if (ddata->dd_ddoor_descriptor < 0) {
			warning(gettext("main_servproc: door_create of Death "
			    "Door failed = %d\n"), errno);
		} else {
			(void) door_setparam(ddata->dd_ddoor_descriptor,
			    DOOR_PARAM_DATA_MAX, 0);
		}

		debug(5, "main_servproc[%d]: Client Door = %d, "
		    "Death Door = %d", pthread_self(),
		    ddata->dd_cdoor_descriptor, ddata->dd_ddoor_descriptor);

		audit_init(ddata);

		/* wait until sm_server_thread does door_bind() */
		(void) cond_wait(&ddata->dd_cv_bind, &ddata->dd_lock);

		(void) mutex_unlock(&ddata->dd_lock);

		(void) mutex_lock(&svcstate_lock);
		svccount++;
		(void) mutex_unlock(&svcstate_lock);

		if (ddata->dd_ddoor_descriptor < 0) {
			/* Return only the Client Door to the client. */
			ddata->dd_cdoor.d_attributes = (DOOR_DESCRIPTOR);
			my_door_return((char *)&reterror,
			    sizeof (smedia_reterror_t), &ddata->dd_desc[0], 1);
		} else {
			/*
			 * Return the Client Door and Death Door
			 * to the client.
			 */
			debug(5, "retok.cnum = 0x%x\n", retok.cnum);
			ddata->dd_cdoor.d_attributes = (DOOR_DESCRIPTOR);
			ddata->dd_ddoor.d_attributes = (DOOR_DESCRIPTOR);
			my_door_return((char *)&retok,
			    sizeof (smedia_reterror_t), &ddata->dd_desc[0], 2);
		}
		break;
	}

	debug(10, "exiting main_servproc. \n");
	my_door_return((char *)&reterror, sizeof (smedia_reterror_t), 0, 0);
}

/* ARGSUSED */
static void
term_handler(int sig, siginfo_t *siginfo, void *sigctx)
{
	warning(gettext("thread[%d]: Received signal %d. Ignoring it.\n"),
	    pthread_self(),
	    sig);
}

/* ARGSUSED */
static void
hup_handler(int sig, siginfo_t *siginfo, void *sigctx)
{
	warning(gettext("thread[%d]: Received signal %d. Ignoring it.\n"),
	    pthread_self(),
	    sig);
}

/*ARGSUSED*/
static void
sig_handler(int sig, siginfo_t *siginfo, void *sigctx)
{
	warning(gettext("thread[%d]: Received signal %d. Ignoring it.\n"),
	    pthread_self(),
	    sig);
}

/*ARGSUSED*/
static void
badsig_handler(int sig, siginfo_t *siginfo, void *sigctx)
{
	fatal(BADSIG_MSG, pthread_self(), sig, siginfo->si_addr,
	    siginfo->si_trapno,
	    siginfo->si_pc);
}

/*ARGSUSED*/
static void *
init_server(void *argp)
{
	int	i, fd;
	struct	sigaction	act;
	struct	rlimit		rlim;

	debug(10, "init_server  running\n");

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);


	if (geteuid() != 0) fatal("Must be root to execute smserverd\n");


	/*
	 * setup signal handlers.
	 */

	for (i = 0; i < N_BADSIGS; i++) {
		act.sa_sigaction = badsig_handler;
		(void) sigemptyset(&act.sa_mask);
		act.sa_flags = SA_SIGINFO;
		if (sigaction(badsigs[i], &act, NULL) == -1)
			warning(gettext(SIGACT_FAILED), strsignal(badsigs[i]),
				strerror(errno));
	}

	/*
	 * Ignore SIGHUP until all the initialization is done.
	 */
	act.sa_handler = SIG_IGN;
	(void) sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	if (sigaction(SIGHUP, &act, NULL) == -1)
		warning(gettext(SIGACT_FAILED), strsignal(SIGHUP),
			strerror(errno));
	/*
	 * Increase file descriptor limit to the most it can possibly
	 * be.
	 */
	if (getrlimit(RLIMIT_NOFILE, &rlim) < 0) {
		warning(gettext("getrlimit for fd's failed; %m\n"));
	}

	rlim.rlim_cur = rlim.rlim_max;

	if (setrlimit(RLIMIT_NOFILE, &rlim) < 0) {
		warning(gettext("setrlimit for fd's failed; %m\n"));
	}

	server_door = door_create(main_servproc, (void *)&server_data, 0);
	if (server_door == -1) {
		debug(1, "main door_create");
		exit(1);
	}

	(void) unlink(smedia_service);
	fd = open(smedia_service, O_RDWR|O_CREAT|O_EXCL, 0644);
	if (fd < 0) {
		debug(5, "could not open %s.\n", smedia_service);
		exit(1);
	}
	(void) close(fd);
	server_fd = fattach(server_door, smedia_service);
	if (server_fd == -1) {
		debug(1, "main fattach");
		exit(1);
	}
	server_data.sd_door = server_door;
	server_data.sd_fd = server_fd;

	/*
	 * setup signal handlers for post-init
	 */

	act.sa_sigaction = hup_handler;
	(void) sigemptyset(&act.sa_mask);
	act.sa_flags = SA_SIGINFO;
	if (sigaction(SIGHUP, &act, NULL) == -1)
		warning(gettext(SIGACT_FAILED), strsignal(SIGHUP),
		    strerror(errno));

	act.sa_sigaction = term_handler;
	(void) sigemptyset(&act.sa_mask);
	act.sa_flags = SA_SIGINFO;
	if (sigaction(SIGTERM, &act, NULL) == -1)
		warning(gettext(SIGACT_FAILED), strsignal(SIGTERM),
		    strerror(errno));

	act.sa_sigaction = sig_handler;
	(void) sigemptyset(&act.sa_mask);
	act.sa_flags = SA_SIGINFO;
	if (sigaction(SIGINT, &act, NULL) == -1)
		warning(gettext(SIGACT_FAILED), strsignal(SIGHUP),
		    strerror(errno));

	act.sa_sigaction = sig_handler;
	(void) sigemptyset(&act.sa_mask);
	act.sa_flags = SA_SIGINFO;
	if (sigaction(SIGQUIT, &act, NULL) == -1)
		warning(gettext(SIGACT_FAILED), strsignal(SIGHUP),
		    strerror(errno));
	debug(10, "init_server completed successfully\n");

	server_data.sd_init_state = INIT_DONE;
	return (NULL);
}

static int
server_exists()
{
	door_arg_t		darg;
	smedia_reqping_t	req_ping;
	smedia_retping_t	*ret_ping;
	int			doorh;
	door_info_t		dinfo;
	char    rbuf[sizeof (smedia_services_t) + sizeof (door_desc_t)];

	doorh = open(smedia_service, O_RDONLY);
	if (doorh < 0)
		return (0);
	if (door_info(doorh, &dinfo) < 0) {
		(void) close(doorh);
		return (0);
	}
	if (dinfo.di_attributes & DOOR_REVOKED) {
		(void) close(doorh);
		return (0);
	}

	req_ping.cnum = SMEDIA_CNUM_PING;

	darg.data_ptr = (char *)&req_ping;
	darg.data_size = sizeof (smedia_reqping_t);
	darg.desc_ptr = NULL;
	darg.desc_num = 0;
	darg.rbuf = rbuf;
	darg.rsize = sizeof (rbuf);

	if (door_call(doorh, &darg) < 0) {
		(void) close(doorh);
		return (0);
	}
	ret_ping = (smedia_retping_t *)((void *)darg.data_ptr);
	if (ret_ping->cnum != SMEDIA_CNUM_PING) {
		(void) close(doorh);
		return (0);
	}

	(void) close(doorh);
	return (1);
}

static int
get_run_level()
{
	int	run_level;
	struct utmpx	*utmpp;

	setutxent();
	while ((utmpp = getutxent()) != NULL) {
		if (utmpp->ut_type == RUN_LVL) {
			run_level = atoi(
				&utmpp->ut_line[strlen("run-level ")]);
		}
	}
	return (run_level);
}

/*ARGSUSED*/
static void *
closedown(void *arg)
{

	int	current_run_level;

	/*CONSTCOND*/
#ifndef lint
	while (1) {
#endif
		(void) sleep(SVC_CLOSEDOWN/2);

		/*
		 * If the server was started at init level 1
		 * and the current init level is 1 then
		 * do not exit from server. This server will run
		 * until it is explicitly stopped by the user.
		 */
		if (svcstart_level == 1) {
			current_run_level = get_run_level();
			if (current_run_level == 1)
#ifndef lint
				continue;
#else
				return (NULL);
#endif
			/*
			 * who ever started the server at level 1 has
			 * forgotten to stop the server. we will kill ourself.
			 */
			debug(5,
			"Terminating the server started at init level 1\n");
			exit(0);
		}

		if (mutex_trylock(&svcstate_lock) != 0)
#ifndef lint
			continue;
#else
			return (NULL);
#endif
		if (svcstate == _IDLE && svccount == 0) {
			int size;
			int i, openfd = 0;

			size = svc_max_pollfd;
			for (i = 0; i < size && openfd < 2; i++)
				if (svc_pollfd[i].fd >= 0)
					openfd++;
			if (openfd <= 1) {
				debug(5,
				"Exiting the server from closedown routine.\n");
				exit(0);
			}
		} else
			svcstate = _IDLE;

		(void) mutex_unlock(&svcstate_lock);
#ifndef lint
	}
#else
	return (NULL);
#endif

}

static void
usage()
{
	warning(gettext("usage: %s [-L loglevel] level of debug information\n"),
		prog_name);
}


/*ARGSUSED*/
int
main(int argc, char **argv)
{
	int c;
	pthread_attr_t	attr;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	prog_name = argv[0];

	(void) sigset(SIGPIPE, SIG_IGN);

	while ((c = getopt(argc, argv, "L:")) != -1) {
		switch (c) {
		case 'L':
			debug_level = atoi((char *)optarg);
			break;
		default:
			usage();
			break;
		}
	}

	/*
	 * If stdin looks like a TLI endpoint, we assume
	 * that we were started by a port monitor. If
	 * t_getstate fails with TBADF, this is not a
	 * TLI endpoint.
	 */
	if (t_getstate(0) != -1 || t_errno != TBADF) {
		char *netid;
		struct netconfig *nconf = NULL;
		SVCXPRT *transp;
		int pmclose;

		openlog(prog_name, LOG_PID, LOG_DAEMON);

		debug(1, gettext("server started by port monitor.\n"));
		if ((netid = getenv("NLSPROVIDER")) == NULL) {
		/* started from inetd */
			pmclose = 1;
		} else {
			if ((nconf = getnetconfigent(netid)) == NULL)
				syslog(LOG_ERR, gettext(
					"cannot get transport info"));

			pmclose = (t_getstate(0) != T_DATAXFER);
		}
		if ((transp = svc_tli_create(0, nconf, NULL, 0, 0)) == NULL) {
			syslog(LOG_ERR, gettext("cannot create server handle"));
			exit(1);
		}
		if (nconf)
			freenetconfigent(nconf);
		if (!svc_reg(transp, SMSERVERPROG, SMSERVERVERS,
			smserverprog_1, 0)) {
			syslog(LOG_ERR, gettext(
			"unable to register (SMSERVERPROG, SMSERVERVERS)."));
			exit(1);
		}
		svcstart_level = get_run_level();
		if (pmclose) {
			(void) pthread_attr_init(&attr);
			(void) pthread_attr_setscope(&attr,
				PTHREAD_SCOPE_SYSTEM | PTHREAD_CREATE_DETACHED);
			if (pthread_create(NULL, &attr, closedown, NULL) != 0) {
				syslog(LOG_ERR, gettext(
					"cannot create closedown thread"));
				exit(1);
			}
			(void) pthread_attr_destroy(&attr);
		}
		svc_run();
		exit(1);
		/* NOTREACHED */
	} else {
		/*
		 * Started by library or manually.
		 */
		/*
		 * Check to see if the server is already running.
		 * There is no need to log messages in the syslog file
		 * because server will get launched each time libsmedia
		 * library calls are made at init 1 level.
		 * We ensure that only one copy will run.
		 */
		debug(1, gettext("server started manually.\n"));
		if (server_exists()) {
			exit(0);
		}
		svcstart_level = get_run_level();
		(void) pthread_attr_init(&attr);
		(void) pthread_attr_setscope(&attr,
			PTHREAD_SCOPE_SYSTEM | PTHREAD_CREATE_DETACHED);
		if (pthread_create(NULL, &attr, closedown, NULL) != 0) {
			syslog(LOG_ERR, gettext(
				"cannot create closedown thread"));
			exit(1);
		}
		(void) pthread_attr_destroy(&attr);
		(void) init_server(NULL);
		for (;;) (void) pause();
	}
	return (0);
}


/*ARGSUSED*/
static int32_t
scsi_floppy_write_protect(int32_t fd, smwp_state_t *wp)
{
	debug(5, "Invalid mode\n");
	errno = ENOTSUP;

	return (-1);
}

/*
 * Generate standard geometry information for SCSI floppy devices. And
 * register the geometry with the SCSI driver. This will expand as more
 * formats are added.
 */

/*ARGSUSED*/
static int32_t
get_floppy_geom(int32_t fd, uint32_t capacity, struct dk_geom *dkgeom)
{


	debug(5, "get_floppy_geom: capacity = 0x%x\n", capacity);

	switch (capacity) {

		case 0x5A0:
			/* Double Density 720K */
			dkgeom->dkg_pcyl = 80;
			dkgeom->dkg_ncyl = 80;
			dkgeom->dkg_nhead = 2;
			dkgeom->dkg_nsect = 9;
			break;
		case 0x4D0:
			/* High Density 1.25MB */
			dkgeom->dkg_pcyl = 77;
			dkgeom->dkg_ncyl = 77;
			dkgeom->dkg_nhead = 2;
			dkgeom->dkg_nsect = 9;
			break;
		case 0xB40:
			/* High Density 1.44MB */

			dkgeom->dkg_pcyl = 80;
			dkgeom->dkg_ncyl = 80;
			dkgeom->dkg_nhead = 2;
			dkgeom->dkg_nsect = 18;
			break;
		case 0x3C300:
			/* Ultra High density ls-120 120MB */
			dkgeom->dkg_pcyl = 963;
			dkgeom->dkg_ncyl = 963;
			dkgeom->dkg_nhead = 8;
			dkgeom->dkg_nsect = 32;
			break;
		default:
			debug(5, "unknown capacity type %d\n", capacity);
			return (-1);

	}
	debug(5, "get_floppy_geom: setting cyl = %d, nsect = %d, head = %d",
		dkgeom->dkg_pcyl, dkgeom->dkg_nhead, dkgeom->dkg_nsect);
	return (0);

}
/* ARGSUSED */
static int32_t
scsi_floppy_format(int32_t fd, uint_t flavor, uint_t mode)
{
	struct uscsi_cmd ucmd;
	uchar_t		cdb[12];
	int32_t		ret_val;
	uint32_t	capacity, blocksize;
	uchar_t		data[12];
	char 		rq_data[RQ_LEN];
	int		i;
	struct dk_geom	dkgeom;

	debug(5, "scsi_floppy_format:\n");

	if ((mode != SM_FORMAT_IMMEDIATE) && (mode != SM_FORMAT_BLOCKED)) {
		errno = ENOTSUP;

		return (-1);
	}

	switch (flavor) {
		case SM_FORMAT_QUICK :
			debug(1, "Format not supported\n");
			errno = ENOTSUP;
			return (-1);
		case SM_FORMAT_FORCE :
			break;
		case SM_FORMAT_LONG :
			break;

		default :
			debug(1, "Format option not specified!!\n");
			errno = ENOTSUP;
			return (-1);
	}

	ret_val = get_media_capacity(fd, &capacity, &blocksize);

	if (capacity >= 0x3C300) {
		/*
		 * It's an LS-120 media, it does not support track
		 * formatting.
		 */
		return (scsi_ls120_format(fd, flavor, capacity, blocksize));
	}

	ret_val = get_floppy_geom(fd, capacity, &dkgeom);
		if (ret_val) {
			errno = ENOTSUP;
			return (-1);
		}

	(void) memset((void *)&data, 0, sizeof (data));
	(void) memset((void *)&ucmd, 0, sizeof (ucmd));
	(void) memset((void *)&cdb, 0, sizeof (cdb));

	/* retrieve size discriptor of inserted media */
	cdb[0] = SCMD_FORMAT;	/* format */

	/*
	 * Defect list sent by initiator is a complete list of defects.
	 */

	cdb[1] = (FMTDATA | 0x7);

	cdb[8] = 0xC;   /* parameter list length */
	data[3] = 0x8;	/* should be always 8 */

	data[4] = (uchar_t)(capacity >> 24);
	data[5] = (uchar_t)(capacity >> 16);
	data[6] = (uchar_t)(capacity >> 8);
	data[7] = (uchar_t)capacity;

	data[9] = (uchar_t)(blocksize >> 16);
	data[10] = (uchar_t)(blocksize >> 8);
	data[11] = (uchar_t)blocksize;

	ucmd.uscsi_cdb = (caddr_t)&cdb;
	ucmd.uscsi_cdblen = CDB_GROUP5;
	ucmd.uscsi_bufaddr = (caddr_t)data;
	ucmd.uscsi_buflen = sizeof (data);
	ucmd.uscsi_timeout = 0x15;
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;

	debug(5, "cdb: %x %x %x ... %x", cdb[0], cdb[1], cdb[2], cdb[8]);
	debug(5, "data: %x %x %x %x\n", data[0], data[1], data[2], data[3]);
	debug(5, "    : %x %x %x %x\n", data[4], data[5], data[6], data[7]);
	debug(5, "    : %x %x %x %x\n", data[8], data[9], data[10], data[11]);

	for (i = 0; i < dkgeom.dkg_pcyl; i++) {	/* number of tracks */
		data[1] = (0xb0 | FOV);
		cdb[2] = i;

		(void) fflush(stdout);
		ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_WRITE|USCSI_RQENABLE);
		info("format side 0 returned : 0x%x\n", ret_val);

		if (ret_val || ucmd.uscsi_status) {
			debug(5, "Retrieving media info failed: %d - %d\n",
			    ret_val, ucmd.uscsi_status);
			if ((rq_data[2] == KEY_DATA_PROTECT) &&
			    (rq_data[12] == 0x30) && (rq_data[13] == 0)) {
				debug(5, "Invalid command for media\n");
				errno = EINVAL;
			}

			if ((rq_data[2] == KEY_NOT_READY) &&
			    (rq_data[12] == 0x30)) {
				debug(5, "Incompatible media.\n");
				errno = EINVAL;
			}

			return (-1);
		}
		data[1] = (0xb0 | FOV) + 1;
		ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_WRITE|USCSI_RQENABLE);
		info("format side 1 returned : 0x%x\n", ret_val);

		if (ret_val || ucmd.uscsi_status) {
			debug(5, "Retrieving media info failed: %d - %d\n",
			    ret_val, ucmd.uscsi_status);
			if ((rq_data[2] == KEY_DATA_PROTECT) &&
			    (rq_data[12] == 0x30) && (rq_data[13] == 0)) {
				(void) info("Invalid command for media\n");
				errno = EINVAL;
			}

			if ((rq_data[2] == KEY_NOT_READY) &&
			    (rq_data[12] == 0x30)) {
				debug(5, "Incompatible media.\n");
				errno = EINVAL;
			}

			return (-1);
		}
	}

	debug(5, "formatting done!");
	return (0);
}


/* ARGSUSED */
static int32_t
scsi_floppy_media_status(int32_t fd)
{
	struct mode_header_g1 modeh;
	struct uscsi_cmd ucmd;
	uchar_t cdb[10];
	int32_t ret_val;
	int32_t cur_status;
	char rq_data[RQ_LEN];

	debug(5, "SCSI MEDIA STATUS CALLED \n");

	(void) memset((void *) &modeh, 0, sizeof (modeh));
	(void) memset((void *) &ucmd, 0, sizeof (ucmd));
	(void) memset(cdb, 0, sizeof (cdb));
	/*
	 * issue 10 byte mode sense (0x5A)
	 */
	cdb[0] = SCMD_MODE_SENSE_G1;
	cdb[7] = sizeof (modeh) >> 8;
	cdb[8] = sizeof (modeh) & 0xff;

	ucmd.uscsi_cdb = (caddr_t)cdb;
	ucmd.uscsi_cdblen = CDB_GROUP1;
	ucmd.uscsi_bufaddr = (caddr_t)&modeh;
	ucmd.uscsi_buflen = sizeof (modeh);
	ucmd.uscsi_timeout = 120;	/* If 0, HBA hangs forever */
	ucmd.uscsi_rqlen = RQ_LEN;
	ucmd.uscsi_rqbuf = rq_data;
	ret_val = do_uscsi_cmd(fd, &ucmd, USCSI_READ|USCSI_RQENABLE);
	if (ret_val || ucmd.uscsi_status) {
		/*
		 * UFI devices may not respond to the 0 mode page.
		 * retry with the error recovery page(0x01)
		 */
		if (ucmd.uscsi_status & STATUS_CHECK) {
			cdb[2] = 0x1;	/* page code */
			ret_val = do_uscsi_cmd(fd, &ucmd,
					USCSI_READ|USCSI_RQENABLE);
		}
		if (ret_val || ucmd.uscsi_status) {
			debug(1, "Modesense failed: %d - %d\n",
				ret_val, ucmd.uscsi_status);
			return (-1);
		}
	}
	debug(5, "Modesense succeeded: 0x%x\n", modeh.device_specific);

	if (modeh.device_specific & 0x80) {
		cur_status = SM_WRITE_PROTECT_NOPASSWD;
	} else {
		cur_status = SM_WRITE_PROTECT_DISABLE;
	}
	return (cur_status);
}