/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdlib.h>
#include <unistd.h>
#include <wait.h>
#include <sys/time.h>
#include <syslog.h>

#include <meta.h>
#include <sys/lvm/mdio.h>
#include <sys/lvm/md_mddb.h>
#include <sys/lvm/md_mirror.h>

#define	MAX_N_ARGS 64
#define	MAX_ARG_LEN 1024
#define	MAX_SLEEPS 99
#define	SLEEP_MOD 5

/* we reserve 1024 bytes for stdout and the same for stderr */
#define	MAX_OUT	1024
#define	MAX_ERR	1024
#define	JUNK 128 /* used to flush stdout and stderr */


/*ARGSUSED*/
void
mdmn_do_cmd(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{

	/*
	 * We are given one string containing all the arguments
	 * For execvp() we have to regenerate the arguments again
	 */
	int	arg;		/* argument that is currently been built */
	int	index;		/* runs through arg above */
	int	i;		/* helper for for loop */
	char	*argv[MAX_N_ARGS]; /* argument array for execvp */
	char	*cp;		/* runs through the given command line string */
	char	*command = NULL; /* the command we call locally */
	int	pout[2];	/* pipe for stdout */
	int	perr[2];	/* pipe for stderr */
	pid_t	pid;		/* process id */

	cp	= msg->msg_event_data;
	arg	= 0;
	index	= 0;

	/* init the args array alloc the first one and null out the rest */
	argv[0] = Malloc(MAX_ARG_LEN);
	for (i = 1; i < MAX_N_ARGS; i++) {
		argv[i] = NULL;
	}

	resp->mmr_comm_state	= MDMNE_ACK; /* Ok state */;

	while (*cp != '\0') {
		if (arg == MAX_N_ARGS) {
			(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
			    "PANIC: too many arguments specified\n"));
			resp->mmr_comm_state = MDMNE_HANDLER_FAILED;
			goto out;
		}
		if (index == MAX_ARG_LEN) {
			(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
			    "PANIC: argument too long\n"));
			resp->mmr_comm_state = MDMNE_HANDLER_FAILED;
			goto out;
		}

		if ((*cp != ' ') && (*cp != '\t')) {
			/*
			 * No space or tab: copy char into current
			 * argv and advance both pointers
			 */

			argv[arg][index] = *cp;
			cp++;	/* next char in command line	*/
			index++;	/* next char in argument	*/
		} else {
			/*
			 * space or tab: terminate current argv,
			 * advance arg, reset pointer into arg,
			 * advance pointer in command line
			 */
			argv[arg][index] = '\0';
			arg++; /* next argument */
			argv[arg] = Malloc(MAX_ARG_LEN);
			cp++; /* next char in command line */
			index = 0; /* starts at char 0 */
		}
	}
	/* terminate the last real argument */
	argv[arg][index] = '\0';
	/* the last argument is an NULL pointer */
	argv[++arg] = NULL;
	if (pipe(pout) < 0)  {
		(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
		    "PANIC: pipe failed\n"));
		resp->mmr_comm_state = MDMNE_HANDLER_FAILED;
		goto out;
	}
	if (pipe(perr) < 0) {
		(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
		    "PANIC: pipe failed\n"));
		(void) close(pout[0]);
		(void) close(pout[1]);
		resp->mmr_comm_state = MDMNE_HANDLER_FAILED;
		goto out;
	}
	command = Strdup(argv[0]);
	(void) strcat(argv[0], ".rpc_call");
	pid = fork1();
	if (pid == (pid_t)-1) {
		(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
		    "PANIC: fork failed\n"));
		resp->mmr_comm_state = MDMNE_HANDLER_FAILED;
		(void) close(pout[0]);
		(void) close(pout[1]);
		(void) close(perr[0]);
		(void) close(perr[1]);
		goto out;
	} else  if (pid == (pid_t)0) {
		/* child */
		(void) close(0);
		/* close the reading channels of pout and perr */
		(void) close(pout[0]);
		(void) close(perr[0]);
		/* redirect stdout */
		if (dup2(pout[1], 1) < 0) {
			(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
			    "PANIC: dup2 failed\n"));
			resp->mmr_comm_state = MDMNE_HANDLER_FAILED;
			return;
		}

		/* redirect stderr */
		if (dup2(perr[1], 2) < 0) {
			(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
			    "PANIC: dup2 failed\n"));
			resp->mmr_comm_state = MDMNE_HANDLER_FAILED;
			return;
		}

		(void) execvp(command, (char *const *)argv);
		perror("execvp");
		_exit(1);
	} else {
		/* parent process */
		int stat_loc;
		char *out, *err; /* for stdout and stderr of child */
		int i; /* index into the aboves */
		char junk[JUNK];
		int out_done = 0;
		int err_done = 0;
		int out_read = 0;
		int err_read = 0;
		int maxfd;
		fd_set	rset;


		/* close the writing channels of pout and perr */
		(void) close(pout[1]);
		(void) close(perr[1]);
		resp->mmr_out = Malloc(MAX_OUT);
		resp->mmr_err = Malloc(MAX_ERR);
		resp->mmr_out_size = MAX_OUT;
		resp->mmr_err_size = MAX_ERR;
		out = resp->mmr_out;
		err = resp->mmr_err;
		FD_ZERO(&rset);
		while ((out_done == 0) || (err_done == 0)) {
			FD_SET(pout[0], &rset);
			FD_SET(perr[0], &rset);
			maxfd = max(pout[0], perr[0]) + 1;
			(void) select(maxfd, &rset, NULL, NULL, NULL);

			/*
			 * Did the child produce some output to stdout?
			 * If so, read it until we either reach the end of the
			 * output or until we read MAX_OUT bytes.
			 * Whatever comes first.
			 * In case we already read MAX_OUT bytes we simply
			 * read away the output into a junk buffer.
			 * Just to make the child happy
			 */
			if (FD_ISSET(pout[0], &rset)) {
				if (MAX_OUT - out_read - 1 > 0) {
					i = read(pout[0], out,
					    MAX_OUT - out_read);
					out_read += i;
					out += i;
				} else {
					/* buffer full, empty stdout */
					i = read(pout[0], junk, JUNK);
				}
				if (i == 0) {
					/* stdout is closed by child */
					out_done++;
				}
			}
			/* same comment as above | sed -e 's/stdout/stderr/' */
			if (FD_ISSET(perr[0], &rset)) {
				if (MAX_ERR - err_read - 1 > 0) {
					i = read(perr[0], err,
					    MAX_ERR - err_read);
					err_read += i;
					err += i;
				} else {
					/* buffer full, empty stderr */
					i = read(perr[0], junk, JUNK);
				}
				if (i == 0) {
					/* stderr is closed by child */
					err_done++;
				}
			}
		}
		resp->mmr_out[out_read] = '\0';
		resp->mmr_err[err_read] = '\0';

		while (waitpid(pid, &stat_loc, 0) < 0) {
			if (errno != EINTR) {
				resp->mmr_comm_state = MDMNE_HANDLER_FAILED;
				break;
			}
		}
		if (errno == 0)
			resp->mmr_exitval = WEXITSTATUS(stat_loc);

		(void) close(pout[0]);
		(void) close(perr[0]);
	}
out:
	for (i = 0; i < MAX_N_ARGS; i++) {
		if (argv[i] != NULL) {
			free(argv[i]);
		}
	}
	if (command != NULL) {
		Free(command);
	}
}

/*
 * This is for checking if a metadevice is opened, and for
 * locking in case it is not and for
 * unlocking a locked device
 */
/*ARGSUSED*/
void
mdmn_do_clu(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	if (msg->msg_type == MD_MN_MSG_CLU_CHECK) {
		md_isopen_t	*d;
		int		ret;

		resp->mmr_comm_state = MDMNE_ACK; /* Ok state */;
		resp->mmr_out_size = 0;
		resp->mmr_err_size = 0;
		resp->mmr_out = NULL;
		resp->mmr_err = NULL;
		d = (md_isopen_t *)(void *)msg->msg_event_data;
		ret = metaioctl(MD_IOCISOPEN, d, &(d->mde), NULL);
		/*
		 * In case the ioctl succeeded, return the open state of
		 * the metadevice. Otherwise we return the error the ioctl
		 * produced. As this is not zero, no attempt is made to
		 * remove/rename the metadevice later
		 */

		if (ret == 0) {
			resp->mmr_exitval = d->isopen;
		} else {
			/*
			 * When doing a metaclear, one node after the other
			 * does the two steps:
			 * - check on all nodes if this md is opened.
			 * - remove the md locally.
			 * When the 2nd node asks all nodes if the md is
			 * open it starts with the first node.
			 * As this already removed the md, the check
			 * returns MDE_UNIT_NOT_SETUP.
			 * In order to not keep the 2nd node from proceeding,
			 * we map this to an Ok.
			 */
			if (mdismderror(&(d->mde), MDE_UNIT_NOT_SETUP)) {
				mdclrerror(&(d->mde));
				ret = 0;
			}

			resp->mmr_exitval = ret;
		}
	}
}

/* handler for MD_MN_MSG_REQUIRE_OWNER */
/*ARGSUSED*/
void
mdmn_do_req_owner(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_set_mmown_params_t	setown;
	md_mn_req_owner_t	*d;
	int			ret, n = 0;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_req_owner_t *)(void *)msg->msg_event_data;

	(void) memset(&setown, 0, sizeof (setown));
	MD_SETDRIVERNAME(&setown, MD_MIRROR, MD_MIN2SET(d->mnum))
	setown.d.mnum = d->mnum;
	setown.d.owner = d->owner;

	/* Retry ownership change if we get EAGAIN returned */
	while ((ret = metaioctl(MD_MN_SET_MM_OWNER, &setown, &setown.mde, NULL))
	    != 0) {
		md_sys_error_t	*ip =
		    &setown.mde.info.md_error_info_t_u.sys_error;
		if (ip->errnum != EAGAIN) {
			break;
		}
		if (n++ >= 10) {
			break;
		}
		(void) sleep(1);
	}

	resp->mmr_exitval = ret;
}

/*
 * handler for MD_MN_MSG_CHOOSE_OWNER
 * This is called when a mirror resync has no owner. The master node generates
 * this message which is not broadcast to the other nodes. The message is
 * required as the kernel does not have access to the nodelist for the set.
 */
/*ARGSUSED*/
void
mdmn_do_choose_owner(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_chowner_t	chownermsg;
	md_mn_msg_chooseid_t	*d;
	int			ret = 0;
	int			nodecnt;
	int			nodeno;
	uint_t			nodeid;
	uint_t			myflags;
	set_t			setno;
	mdsetname_t		*sp;
	md_set_desc		*sd;
	md_mnnode_desc		*nd;
	md_error_t		mde = mdnullerror;
	md_mn_result_t		*resp1 = NULL;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_chooseid_t *)(void *)msg->msg_event_data;

	/*
	 * The node to be chosen will be the resync count for the set
	 * modulo the number of live nodes in the set
	 */
	setno = MD_MIN2SET(d->msg_chooseid_mnum);
	if ((sp = metasetnosetname(setno, &mde)) == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_MSG_CHOOSE_OWNER: Invalid setno %d\n"), setno);
		resp->mmr_exitval = 1;
		return;
	}
	if ((sd = metaget_setdesc(sp, &mde)) == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_MSG_CHOOSE_OWNER: Invalid set pointer\n"));
		resp->mmr_exitval = 1;
		return;
	}

	/* Count the number of live nodes */
	nodecnt = 0;
	nd = sd->sd_nodelist;
	while (nd) {
		if (nd->nd_flags & MD_MN_NODE_ALIVE)
			nodecnt++;
		nd = nd->nd_next;
	}
	nodeno = (d->msg_chooseid_rcnt%nodecnt);

	/*
	 * If we've been called with msg_chooseid_set_node set TRUE then we
	 * are simply re-setting the owner id to ensure consistency across
	 * the cluster.
	 * If the flag is reset (B_FALSE) we are requesting a new owner to be
	 * determined.
	 */
	if (d->msg_chooseid_set_node) {
		nodeid = d->msg_chooseid_rcnt;
	} else {
		/* scan the nodelist looking for the required node */
		nodecnt = 0;
		nd = sd->sd_nodelist;
		while (nd) {
			if (nd->nd_flags & MD_MN_NODE_ALIVE) {
				if (nodecnt == nodeno)
					break;
				nodecnt++;
			}
			nd = nd->nd_next;
		}
		nodeid = nd->nd_nodeid;
	}

	/* Send message to all nodes to make ownership change */
	chownermsg.msg_chowner_mnum =  d->msg_chooseid_mnum;
	chownermsg.msg_chowner_nodeid = nodeid;
	myflags = MD_MSGF_NO_LOG;

	/* inherit some flags from the parent message */
	myflags |= msg->msg_flags & MD_MSGF_INHERIT_BITS;

	ret = mdmn_send_message(MD_MIN2SET(d->msg_chooseid_mnum),
	    MD_MN_MSG_CHANGE_OWNER, myflags, 0, (char *)&chownermsg,
	    sizeof (chownermsg), &resp1, &mde);
	if (resp1 != NULL)
		free_result(resp1);
	resp->mmr_exitval = ret;
}

/*
 * Handler for MD_MN_MSG_CHANGE_OWNER
 * This is called when we are perfoming a resync and wish to change from
 * no mirror owner to an owner chosen by the master.
 * This mesage is only relevant for the new owner, the message will be
 * ignored by all other nodes
 */
/*ARGSUSED*/
void
mdmn_do_change_owner(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_set_mmown_params_t	setown;
	md_mn_msg_chowner_t	*d;
	int			ret = 0;
	set_t			setno;
	mdsetname_t		*sp;
	md_set_desc		*sd;
	md_error_t		mde = mdnullerror;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_chowner_t *)(void *)msg->msg_event_data;

	setno = MD_MIN2SET(d->msg_chowner_mnum);
	if ((sp = metasetnosetname(setno, &mde)) == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_MSG_CHANGE_OWNER: Invalid setno %d\n"), setno);
		resp->mmr_exitval = 1;
		return;
	}
	if ((sd = metaget_setdesc(sp, &mde)) == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_MSG_CHANGE_OWNER: Invalid set pointer\n"));
		resp->mmr_exitval = 1;
		return;
	}

	if (d->msg_chowner_nodeid == sd->sd_mn_mynode->nd_nodeid) {
		/*
		 * If we are the chosen owner, issue ioctl to make the
		 * ownership change
		 */
		(void) memset(&setown, 0, sizeof (md_set_mmown_params_t));
		setown.d.mnum = d->msg_chowner_mnum;
		setown.d.owner = d->msg_chowner_nodeid;
		setown.d.flags = MD_MN_MM_SPAWN_THREAD;
		MD_SETDRIVERNAME(&setown, MD_MIRROR,
		    MD_MIN2SET(d->msg_chowner_mnum));

		/*
		 * Single shot at changing the the owner, if it fails EAGAIN,
		 * another node must have become the owner while we are in the
		 * process of making this choice.
		 */

		ret = metaioctl(MD_MN_SET_MM_OWNER, &setown,
		    &(setown.mde), NULL);
		if (ret == EAGAIN)
			ret = 0;
	}
	resp->mmr_exitval = ret;
}

/* handler for MD_MN_MSG_SUSPEND_WRITES */
/*ARGSUSED*/
void
mdmn_do_susp_write(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	/* Suspend writes to a region of a mirror */
	md_suspend_wr_params_t	suspwr_ioc;
	md_mn_msg_suspwr_t	*d;
	int			ret;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_suspwr_t *)(void *)msg->msg_event_data;

	(void) memset(&suspwr_ioc, 0, sizeof (md_suspend_wr_params_t));
	MD_SETDRIVERNAME(&suspwr_ioc, MD_MIRROR,
	    MD_MIN2SET(d->msg_suspwr_mnum));
	suspwr_ioc.mnum = d->msg_suspwr_mnum;
	ret = metaioctl(MD_MN_SUSPEND_WRITES, &suspwr_ioc,
	    &(suspwr_ioc.mde), NULL);
	resp->mmr_exitval = ret;
}

/*
 * handler for MD_MN_MSG_STATE_UPDATE_RESWR
 * This functions update a submirror component state and then resumes writes
 * to the mirror
 */
/*ARGSUSED*/
void
mdmn_do_state_upd_reswr(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	/* Update the state of the component of a mirror */
	md_set_state_params_t	setstate_ioc;
	md_mn_msg_stch_t	*d;
	int			ret;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_stch_t *)(void *)msg->msg_event_data;

	(void) memset(&setstate_ioc, 0, sizeof (md_set_state_params_t));
	MD_SETDRIVERNAME(&setstate_ioc, MD_MIRROR,
	    MD_MIN2SET(d->msg_stch_mnum));
	setstate_ioc.mnum = d->msg_stch_mnum;
	setstate_ioc.sm = d->msg_stch_sm;
	setstate_ioc.comp = d->msg_stch_comp;
	setstate_ioc.state = d->msg_stch_new_state;
	setstate_ioc.hs_id = d->msg_stch_hs_id;
	ret = metaioctl(MD_MN_SET_STATE, &setstate_ioc,
	    &(setstate_ioc.mde), NULL);
	resp->mmr_exitval = ret;
}

/*
 * submessage generator for MD_MN_MSG_STATE_UPDATE and MD_MN_MSG_STATE_UPDATE2
 * This generates 2 messages, the first is SUSPEND_WRITES and
 * depending on the type of the original message the second one is
 * either STATE_UPDATE_RESWR or STATE_UPDATE_RESWR2 which actually does
 * the same, but runs on a higher class.
 */
int
mdmn_smgen_state_upd(md_mn_msg_t *msg, md_mn_msg_t *msglist[])
{
	md_mn_msg_t		*nmsg;
	md_mn_msg_stch_t	*d;
	md_mn_msg_stch_t	*stch_data;
	md_mn_msg_suspwr_t	*suspwr_data;

	d = (md_mn_msg_stch_t *)(void *)msg->msg_event_data;

	nmsg = Zalloc(sizeof (md_mn_msg_t));
	MSGID_COPY(&(msg->msg_msgid), &(nmsg->msg_msgid));

	nmsg->msg_flags		= MD_MSGF_NO_LOG; /* Don't log submessages */
	nmsg->msg_setno		= msg->msg_setno;
	nmsg->msg_type		= MD_MN_MSG_SUSPEND_WRITES;
	nmsg->msg_event_size	= sizeof (md_mn_msg_suspwr_t);
	nmsg->msg_event_data	= Zalloc(sizeof (md_mn_msg_suspwr_t));
	suspwr_data = (md_mn_msg_suspwr_t *)(void *)nmsg->msg_event_data;
	suspwr_data->msg_suspwr_mnum = d->msg_stch_mnum;
	msglist[0] = nmsg;

	nmsg = Zalloc(sizeof (md_mn_msg_t));
	MSGID_COPY(&(msg->msg_msgid), &(nmsg->msg_msgid));

	nmsg->msg_flags		= MD_MSGF_NO_LOG; /* Don't log submessages */
	nmsg->msg_setno		= msg->msg_setno;
	if (msg->msg_type == MD_MN_MSG_STATE_UPDATE2) {
		nmsg->msg_type		= MD_MN_MSG_STATE_UPDATE_RESWR2;
	} else {
		nmsg->msg_type		= MD_MN_MSG_STATE_UPDATE_RESWR;
	}
	nmsg->msg_event_size	= sizeof (md_mn_msg_stch_t);
	nmsg->msg_event_data	= Zalloc(sizeof (md_mn_msg_stch_t));
	stch_data = (md_mn_msg_stch_t *)(void *)nmsg->msg_event_data;
	stch_data->msg_stch_mnum = d->msg_stch_mnum;
	stch_data->msg_stch_sm = d->msg_stch_sm;
	stch_data->msg_stch_comp = d->msg_stch_comp;
	stch_data->msg_stch_new_state = d->msg_stch_new_state;
	stch_data->msg_stch_hs_id = d->msg_stch_hs_id;
	msglist[1] = nmsg;
	return (2); /* Return the number of submessages generated */
}

/*
 * handler for MD_MN_MSG_ALLOCATE_HOTSPARE and MD_MN_MSG_ALLOCATE_HOTSPARE2
 * This sends a message to all nodes requesting them to allocate a hotspare
 * for the specified component. The component is specified by the mnum of
 * the mirror, the submirror index and the component index.
 */
/*ARGSUSED*/
void
mdmn_do_allocate_hotspare(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	/* Allocate a hotspare for a mirror component */
	md_alloc_hotsp_params_t allochsp_ioc;
	md_mn_msg_allochsp_t    *d;
	int			ret;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_allochsp_t *)((void *)(msg->msg_event_data));

	(void) memset(&allochsp_ioc, 0,
	    sizeof (md_alloc_hotsp_params_t));
	MD_SETDRIVERNAME(&allochsp_ioc, MD_MIRROR,
	    MD_MIN2SET(d->msg_allochsp_mnum));
	allochsp_ioc.mnum = d->msg_allochsp_mnum;
	allochsp_ioc.sm = d->msg_allochsp_sm;
	allochsp_ioc.comp = d->msg_allochsp_comp;
	allochsp_ioc.hs_id = d->msg_allochsp_hs_id;
	ret = metaioctl(MD_MN_ALLOCATE_HOTSPARE, &allochsp_ioc,
	    &(allochsp_ioc.mde), NULL);
	resp->mmr_exitval = ret;
}

/*
 * handler for MD_MN_MSG_RESYNC_STARTING,MD_MN_MSG_RESYNC_FIRST,
 * MD_MN_MSG_RESYNC_NEXT, MD_MN_MSG_RESYNC_FINISH, MD_MN_MSG_RESYNC_PHASE_DONE
 */
/*ARGSUSED*/
void
mdmn_do_resync(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_resync_t		*d;
	md_mn_rs_params_t		respar;
	mddb_setflags_config_t	sf;
	md_error_t				ep = mdnullerror;
	mdsetname_t				*sp;
	int	ret;
	int	smi;
	int start_flag = 1;
	int sleep_count = 0;
	unsigned int sleep_time = 2;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_resync_t *)((void *)(msg->msg_event_data));

	(void) memset(&respar, 0, sizeof (respar));
	MD_SETDRIVERNAME(&respar, MD_MIRROR,
	    MD_MIN2SET(d->msg_resync_mnum))
	respar.msg_type = (int)msg->msg_type;
	respar.mnum = d->msg_resync_mnum;
	respar.rs_type = d->msg_resync_type;
	respar.rs_start = d->msg_resync_start;
	respar.rs_size = d->msg_resync_rsize;
	respar.rs_done = d->msg_resync_done;
	respar.rs_2_do = d->msg_resync_2_do;
	respar.rs_originator = d->msg_originator;
	respar.rs_flags = d->msg_resync_flags;

	for (smi = 0; smi < NMIRROR; smi++) {
		respar.rs_sm_state[smi] = d->msg_sm_state[smi];
		respar.rs_sm_flags[smi] = d->msg_sm_flags[smi];
	}

	/*
	 * Prior to running the resync thread first check that the start_step
	 * flag (MD_SET_MN_START_RC) added by metaclust's MC_START step has been
	 * removed from the set record flags. Ordinarily, this would be removed
	 * at MC_STEP4 in metaclust - need to ensure this has happened on all
	 * nodes.
	 */
	(void) memset(&sf, 0, sizeof (sf));
	sf.sf_setno = MD_MIN2SET(d->msg_resync_mnum);
	sf.sf_flags = MDDB_NM_GET;
	/* Use magic to help protect ioctl against attack. */
	sf.sf_magic = MDDB_SETFLAGS_MAGIC;
	if ((sp = metasetnosetname(sf.sf_setno, &ep)) == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MDMN_DO_RESYNC: Invalid setno = %d\n"),
		    sf.sf_setno);
		(void) mdstealerror(&(resp->mmr_ep), &ep);
		resp->mmr_exitval = -1;
		return;
	}

	/* start_flag always true initially */
	while (start_flag) {
		if (metaioctl(MD_MN_GET_SETFLAGS, &sf, &sf.sf_mde, NULL) != 0) {
			syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
			    "MDMN_DO_RESYNC: Could not get start_step "
			    "flag for set %s - returning\n"),
			    sp->setname);
			(void) mdstealerror(&(resp->mmr_ep), &sf.sf_mde);
			resp->mmr_exitval = -1;
			return;
		}

		/* metaioctl returns successfully - is start flag cleared? */
		if (sf.sf_setflags & MD_SET_MN_START_RC) {
			start_flag = 1;
			(void) sleep(sleep_time);
			sleep_count++;
			if ((sleep_count == 1) ||
			    (sleep_count % SLEEP_MOD) == 0) {
				syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
				    "MDMN_DO_RESYNC: Waiting for start_step "
				    "flag for set %s to be cleared\n"),
				    sp->setname);
			}
			if (sleep_count == MAX_SLEEPS) {
				syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
				    "MDMN_DO_RESYNC: Could not clear "
				    "start_step flag for set %s "
				    "- returning\n"), sp->setname);
				resp->mmr_exitval = -1;
				return;
			}
		} else {
			start_flag = 0;
		}
	}

	ret = metaioctl(MD_MN_RESYNC, &respar, &respar.mde, NULL);
	if (ret) {
		(void) mdstealerror(&(resp->mmr_ep), &respar.mde);
	}
	resp->mmr_exitval = ret;
}

/*
 * handler for MD_MN_MSG_SETSYNC
 */
/*ARGSUSED*/
void
mdmn_do_setsync(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_setsync_t	*d;
	md_resync_ioctl_t	ri;
	int			ret;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_setsync_t *)((void *)(msg->msg_event_data));

	(void) memset(&ri, 0, sizeof (ri));
	MD_SETDRIVERNAME(&ri, MD_MIRROR, MD_MIN2SET(d->setsync_mnum))
	ri.ri_mnum = d->setsync_mnum;
	ri.ri_copysize = d->setsync_copysize;
	ri.ri_flags = d->setsync_flags;

	ret = metaioctl(MD_MN_SETSYNC, &ri, &ri.mde, NULL);

	resp->mmr_exitval = ret;
}

/*
 * handler for MD_MN_MSG_SET_CAP. As this handler can deal with both mirrors
 * and soft partitions, the driver name that is required for the ioctl call
 * is included in the message.
 */
/*ARGSUSED*/
void
mdmn_do_set_cap(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_setcap_t	*d;
	md_mn_setcap_params_t	setcap_ioc;
	minor_t			mnum;
	int			ret;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_setcap_t *)((void *)(msg->msg_event_data));
	mnum = d->msg_setcap_mnum;

	(void) memset(&setcap_ioc, 0, sizeof (setcap_ioc));

	MD_SETDRIVERNAME(&setcap_ioc, d->msg_setcap_driver, MD_MIN2SET(mnum));
	setcap_ioc.mnum = mnum;
	setcap_ioc.sc_set = d->msg_setcap_set;

	ret = metaioctl(MD_MN_SET_CAP, &setcap_ioc, &setcap_ioc.mde, NULL);

	resp->mmr_exitval = ret;
}

/*
 * Dummy handler for various CLASS0 messages like
 * MD_MN_MSG_VERBOSITY / MD_MN_MSG_RESUME / MD_MN_MSG_SUSPEND ...
 */
/*ARGSUSED*/
void
mdmn_do_dummy(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_exitval = 0;
	resp->mmr_comm_state = MDMNE_ACK;
}

/*
 * Overall description of mdcommd support that keeps all nodes in-sync
 * with the ondisk diskset mddbs.
 *
 * All configuration changes to the mddb - addition/deletion of metadevices
 * or replicas must use a CLASS1 message to block out these changes.
 * Changes to the state of existing replicas do not need to block CLASS1
 * since there is no conflict when just updating the state of a replica.
 *
 * Error encountered when master writes to mddbs:
 *	As the master updates parts of the mddbs, flags are updated describing
 *	what has been written.  When all locks are dropped (either in
 *	mddb_setexit or mdioctl), a PARSE message will be generated to all
 *	nodes with an index list of known good mddbs and the parse flags.
 *	The master node ignore the parse message since it sent it.
 *	The slave nodes re-read in the changed part of the mddb using the list
 *	of known good replicas that was passed.
 *	PARSE message does not block CLASS1.
 *	The PARSE message must be the highest class message.  Since this
 *	message could be sent on any ioctl, this PARSE message class must
 *	be higher than any other class message that could issue an ioctl.
 *
 *	Master		Slave1		Slave2
 * 	Handles_error
 *	PARSE		PARSE		PARSE
 *
 *
 * Add/Delete mddbs can occur from the following commands:
 *	metadb -s set_name -a/-d
 *	metaset -s set_name -a/-d disk
 *	metaset -s set_name -b
 *
 *	The metadb/metaset command is run on the node executing the command
 *	and sends an ATTACH/DETACH message to the master node blocking CLASS1
 *	messages on all nodes until this message is finished.  The master
 *	node generates 3 submessages of BLOCK, SM_ATTACH/SM_DETACH, UNBLOCK.
 *	The BLOCK message is only run on the master node and will BLOCK
 *	the PARSE messages from being sent to the nodes.
 *	The SM_ATTACH/SM_DETACH message is run on all nodes and actually adds or
 *	removes the replica(s) from the given disk slice.
 *	The UNBLOCK message is only run on the master node and allows the
 *	sending of PARSE messages.
 *
 *	Master		Slave1		Slave2
 *			Add mddb cmd
 *			ATTACH msg to master
 *	BLOCK
 *	ATTACH		ATTACH		ATTACH
 *	UNBLOCK
 *	PARSE		PARSE		PARSE
 *	ATTACH msg finished
 *
 * Add/Delete host side information from the following commands:
 *	metaset -s set_name -a/-d -h
 *
 *	The metaset command is run on the node executing the command and
 *	sends a DB_NEWSIDE/DB_DELSIDE message and a MD_NEWSIDE/MD_DELSIDE
 *	message whenever a host is added to or deleted from the diskset.
 *
 *	The side information contains the major name and minor number
 *	associated with a disk slice from a certain node's perspective
 *	in an (failed) effort to support clustered systems that don't have the
 *	same device name for a physical device. (The original designers of
 *	SVM eventually took the shortcut of assuming that all device names
 *	are the same on all systems, but left the side information in the
 *	mddb and namespace.)  The side information is used for disk slices
 *	that contain mddbs and/or are components for metadevices.
 *
 *	The DB_NEWSIDE/DELSIDE command adds or deletes the side information
 *	for each mddb for the host being added or deleted.
 *	The MD_ADDSIDE/MD_DELSIDE command adds or deletes the side information
 *	for all disk slice components that are in the namespace records for
 *	the host being added or deleted.
 *
 *	The DB_NEWSIDE/DB_DELSIDE message does not change any mddb records
 *	and only needs to be executed on the master node since the slave
 *	nodes will be brought up to date by the PARSE message that is
 *	generated as a result of a change to the mddb.
 *	The MD_ADDSIDE/MD_DELSIDE message does modify the records in the mddb
 *	and needs to be run on all nodes.  The message must block class1
 *	messages so that record changing commands don't interfere.
 *
 *	Master		Slave1		Slave2
 *			Add host
 *			DB_NEWSIDE msg to master
 *	DB_NEWSIDE
 *	PARSE		PARSE		PARSE
 *	DB_NEWSIDE msg finished
 *			MD_NEWSIDE msg to master
 *	MD_NEWSIDE	MD_NEWSIDE	MD_NEWSIDE
 *	MD_NEWSIDE msg finished
 *
 *
 * Optimized resync record failure:
 *	When any node sees a failure to write an optimized resync record
 *	that node notifies the master node of the replica that failed.
 *	The master node handles the error and updates the rest of the
 *	nodes using a PARSE message.  The PARSE message also calls
 *	fixoptrecord on each slave node causing each node to fix up
 * 	the optimized resync records that are owned by that node (the mirror
 *	owner code also sets the optimized resync record owner).  The master
 *	node will fix up all optimized resync records that have no owner or
 *	are owned by the master node.
 *
 *	Master		Slave1		Slave2
 *					Optimized Record Failure
 *					OPTRECERR msg to master
 *	Master handles opt rec failure
 *	PARSE		PARSE		PARSE
 *	OPTRECERR msg finished
 *					Slave rewrites optimized record
 *
 */

/*
 * Handler for MD_MN_MSG_MDDB_PARSE which send parse messages to the
 * slave nodes in order to keep the incore view of the mddbs the
 * same on all nodes.
 *
 * Since master node generated the mddb parse message, do nothing
 * if this is the master node.
 *
 * If this is a slave node, send the parse message down to the kernel
 * where this node will re-read in parts of the mddbs.
 *
 */
void
mdmn_do_mddb_parse(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_mddb_parse_t	*d;
	mddb_parse_parm_t	mpp;
	int			ret = 0;
	int			i;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_mddb_parse_t *)((void *)(msg->msg_event_data));

	if (flags & MD_MSGF_ON_MASTER)
		return;

	(void) memset(&mpp, 0, sizeof (mpp));
	mpp.c_setno = msg->msg_setno;
	mpp.c_parse_flags = d->msg_parse_flags;
	for (i = 0; i < MDDB_NLB; i++) {
		mpp.c_lb_flags[i] = d->msg_lb_flags[i];
	}
	ret = metaioctl(MD_MN_MDDB_PARSE, &mpp, &mpp.c_mde, NULL);
	if (ret)
		(void) mdstealerror(&(resp->mmr_ep), &mpp.c_mde);

	resp->mmr_exitval = ret;
}

/*
 * Handler for MD_MN_MSG_MDDB_BLOCK which blocks the generation
 * of parse messages from this node.
 *
 * This is needed when attaching/detaching mddbs on the master and the
 * slave node is unable to handle a parse message until the slave node
 * has done the attach/detach of the mddbs.  So, master node will block
 * the parse messages, execute the attach/detach on all nodes and
 * then unblock the parse messages which causes the parse message to
 * be sent to all nodes.
 */
/*ARGSUSED*/
void
mdmn_do_mddb_block(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_mddb_block_t	*d;
	mddb_block_parm_t	mbp;
	int			ret;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_mddb_block_t *)((void *)(msg->msg_event_data));

	(void) memset(&mbp, 0, sizeof (mbp));
	mbp.c_setno = msg->msg_setno;
	mbp.c_blk_flags = d->msg_block_flags;
	ret = metaioctl(MD_MN_MDDB_BLOCK, &mbp, &mbp.c_mde, NULL);
	if (ret)
		(void) mdstealerror(&(resp->mmr_ep), &mbp.c_mde);

	resp->mmr_exitval = ret;
}

/*
 * Submessage generator for MD_MN_MSG_META_DB_ATTACH which generates
 * a BLOCK message on the master node only, a MD_MN_MSG_SM_MDDB_ATTACH
 * message on all nodes and then an UNBLOCK message on the master only.
 */
int
mdmn_smgen_mddb_attach(md_mn_msg_t *msg, md_mn_msg_t *msglist[])
{
	md_mn_msg_t			*nmsg;
	md_mn_msg_meta_db_attach_t	*d;
	md_mn_msg_meta_db_attach_t	*attach_d;
	md_mn_msg_mddb_block_t		*block_d;

	d = (md_mn_msg_meta_db_attach_t *)(void *)msg->msg_event_data;

	nmsg = Zalloc(sizeof (md_mn_msg_t));
	MSGID_COPY(&(msg->msg_msgid), &(nmsg->msg_msgid));

	nmsg->msg_flags		= (MD_MSGF_NO_LOG | MD_MSGF_NO_BCAST);
	nmsg->msg_setno		= msg->msg_setno;
	nmsg->msg_type		= MD_MN_MSG_MDDB_BLOCK;
	nmsg->msg_event_size	= sizeof (md_mn_msg_mddb_block_t);
	nmsg->msg_event_data	= Zalloc(sizeof (md_mn_msg_mddb_block_t));
	block_d = (md_mn_msg_mddb_block_t *)(void *)nmsg->msg_event_data;
	block_d->msg_block_flags = MDDB_BLOCK_PARSE;
	msglist[0] = nmsg;

	nmsg = Zalloc(sizeof (md_mn_msg_t));
	MSGID_COPY(&(msg->msg_msgid), &(nmsg->msg_msgid));

	/* Don't log submessages and panic on inconsistent results */
	nmsg->msg_flags = MD_MSGF_NO_LOG |
	    MD_MSGF_PANIC_WHEN_INCONSISTENT;
	nmsg->msg_setno		= msg->msg_setno;
	nmsg->msg_type		= MD_MN_MSG_SM_MDDB_ATTACH;
	nmsg->msg_event_size	= sizeof (md_mn_msg_meta_db_attach_t);
	nmsg->msg_event_data	= Zalloc(sizeof (md_mn_msg_meta_db_attach_t));
	attach_d = (md_mn_msg_meta_db_attach_t *)
	    (void *)nmsg->msg_event_data;
	attach_d->msg_l_dev = d->msg_l_dev;
	attach_d->msg_cnt = d->msg_cnt;
	attach_d->msg_dbsize = d->msg_dbsize;
	(void) strncpy(attach_d->msg_dname, d->msg_dname, 16);
	attach_d->msg_splitname = d->msg_splitname;
	attach_d->msg_options = d->msg_options;
	msglist[1] = nmsg;

	nmsg = Zalloc(sizeof (md_mn_msg_t));
	MSGID_COPY(&(msg->msg_msgid), &(nmsg->msg_msgid));

	nmsg->msg_flags		= (MD_MSGF_NO_LOG | MD_MSGF_NO_BCAST);
	nmsg->msg_setno		= msg->msg_setno;
	nmsg->msg_type		= MD_MN_MSG_MDDB_BLOCK;
	nmsg->msg_event_size	= sizeof (md_mn_msg_mddb_block_t);
	nmsg->msg_event_data	= Zalloc(sizeof (md_mn_msg_mddb_block_t));
	block_d = (md_mn_msg_mddb_block_t *)(void *)nmsg->msg_event_data;
	block_d->msg_block_flags = MDDB_UNBLOCK_PARSE;
	msglist[2] = nmsg;

	return (3); /* Return the number of submessages generated */
}

/*
 * Submessage generator for MD_MN_MSG_META_DB_DETACH which generates
 * a BLOCK message on the master node only, a MD_MN_MSG_SM_MDDB_DETACH
 * message on all nodes and then an UNBLOCK message on the master only.
 */
int
mdmn_smgen_mddb_detach(md_mn_msg_t *msg, md_mn_msg_t *msglist[])
{
	md_mn_msg_t			*nmsg;
	md_mn_msg_meta_db_detach_t	*d;
	md_mn_msg_meta_db_detach_t	*detach_d;
	md_mn_msg_mddb_block_t		*block_d;

	d = (md_mn_msg_meta_db_detach_t *)(void *)msg->msg_event_data;

	nmsg = Zalloc(sizeof (md_mn_msg_t));
	MSGID_COPY(&(msg->msg_msgid), &(nmsg->msg_msgid));

	nmsg->msg_flags		= (MD_MSGF_NO_LOG | MD_MSGF_NO_BCAST);
	nmsg->msg_setno		= msg->msg_setno;
	nmsg->msg_type		= MD_MN_MSG_MDDB_BLOCK;
	nmsg->msg_event_size	= sizeof (md_mn_msg_mddb_block_t);
	nmsg->msg_event_data	= Zalloc(sizeof (md_mn_msg_mddb_block_t));
	block_d = (md_mn_msg_mddb_block_t *)(void *)nmsg->msg_event_data;
	block_d->msg_block_flags = MDDB_BLOCK_PARSE;
	msglist[0] = nmsg;

	nmsg = Zalloc(sizeof (md_mn_msg_t));
	MSGID_COPY(&(msg->msg_msgid), &(nmsg->msg_msgid));

	/* Don't log submessages and panic on inconsistent results */
	nmsg->msg_flags = MD_MSGF_NO_LOG |
	    MD_MSGF_PANIC_WHEN_INCONSISTENT;
	nmsg->msg_setno		= msg->msg_setno;
	nmsg->msg_type		= MD_MN_MSG_SM_MDDB_DETACH;
	nmsg->msg_event_size	= sizeof (md_mn_msg_meta_db_detach_t);
	nmsg->msg_event_data	= Zalloc(sizeof (md_mn_msg_meta_db_detach_t));
	detach_d = (md_mn_msg_meta_db_detach_t *)
	    (void *)nmsg->msg_event_data;
	detach_d->msg_splitname = d->msg_splitname;
	msglist[1] = nmsg;

	nmsg = Zalloc(sizeof (md_mn_msg_t));
	MSGID_COPY(&(msg->msg_msgid), &(nmsg->msg_msgid));

	nmsg->msg_flags		= (MD_MSGF_NO_LOG | MD_MSGF_NO_BCAST);
	nmsg->msg_setno		= msg->msg_setno;
	nmsg->msg_type		= MD_MN_MSG_MDDB_BLOCK;
	nmsg->msg_event_size	= sizeof (md_mn_msg_mddb_block_t);
	nmsg->msg_event_data	= Zalloc(sizeof (md_mn_msg_mddb_block_t));
	block_d = (md_mn_msg_mddb_block_t *)(void *)nmsg->msg_event_data;
	block_d->msg_block_flags = MDDB_UNBLOCK_PARSE;
	msglist[2] = nmsg;

	return (3); /* Return the number of submessages generated */
}

/*
 * Handler for MD_MN_MSG_SM_MDDB_ATTACH which is used to attach mddbs.
 *
 * Used when running:
 *	metadb -s set_name -a
 * 	metaset -s set_name -a/-d disk
 *	metaset -s set_name -b
 */
/*ARGSUSED*/
void
mdmn_do_sm_mddb_attach(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_meta_db_attach_t	*d;
	struct mddb_config		c;
	int				i;
	int				ret = 0;
	md_error_t			ep = mdnullerror;
	char				*name, *add_name;
	mdname_t			*np;
	mdsetname_t			*sp;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_meta_db_attach_t *)((void *)(msg->msg_event_data));

	(void) memset(&c, 0, sizeof (c));
	c.c_setno = msg->msg_setno;
	c.c_locator.l_dev = meta_cmpldev(d->msg_l_dev);
	(void) strncpy(c.c_locator.l_driver, d->msg_dname,
	    sizeof (c.c_locator.l_driver));
	c.c_devname = d->msg_splitname;
	c.c_locator.l_mnum = meta_getminor(d->msg_l_dev);
	c.c_multi_node = 1;
	if ((sp = metasetnosetname(c.c_setno, &ep)) == NULL) {
		(void) mdstealerror(&(resp->mmr_ep), &ep);
		resp->mmr_exitval = -1;
		return;
	}
	(void) strcpy(c.c_setname, sp->setname);
	c.c_sideno = getmyside(sp, &ep);
	if (c.c_sideno == MD_SIDEWILD) {
		(void) mdstealerror(&(resp->mmr_ep), &ep);
		resp->mmr_exitval = -1;
		return;
	}

	name = splicename(&d->msg_splitname);
	np = metaname(&sp, name, LOGICAL_DEVICE, &ep);
	Free(name);
	if (np == NULL) {
		(void) mdstealerror(&(resp->mmr_ep), &ep);
		resp->mmr_exitval = -1;
		return;
	}
	/*
	 * All nodes in MN diskset must do meta_check_replica
	 * since this causes the shared namespace to be
	 * populated by the md driver names while checking
	 * to see if this device is already in use as a
	 * metadevice.
	 */
	if (meta_check_replica(sp, np, d->msg_options, 0,
	    (d->msg_cnt * d->msg_dbsize), &ep)) {
		(void) mdstealerror(&(resp->mmr_ep), &ep);
		resp->mmr_exitval = -1;
		return;
	}

	for (i = 0; i < d->msg_cnt; i++) {
		c.c_locator.l_blkno = i * d->msg_dbsize + 16;
		if (setup_med_cfg(sp, &c,
		    (d->msg_options & MDCHK_SET_FORCE), &ep)) {
			ret = -1;
			(void) mdstealerror(&(resp->mmr_ep), &ep);
			break;
		}
		ret = metaioctl(MD_DB_NEWDEV, &c, &c.c_mde, NULL);
		/* If newdev was successful, continue with attach */
		if (ret == 0) {
			if (meta_db_addsidenms(sp, np, c.c_locator.l_blkno,
			    DB_ADDSIDENMS_NO_BCAST, &ep)) {
				ret = -1;
				(void) mdstealerror(&(resp->mmr_ep), &ep);
				break;
			}
		} else {
			(void) mdstealerror(&(resp->mmr_ep), &c.c_mde);
			break;
		}
	}
	add_name = splicename(&d->msg_splitname);
	if ((np = metaname(&sp, add_name, LOGICAL_DEVICE, &ep)) != NULL) {
		meta_invalidate_name(np);
	} else {
		ret = -1;
		(void) mdstealerror(&(resp->mmr_ep), &ep);
	}
	Free(add_name);

	resp->mmr_exitval = ret;
}

/*
 * Handler for MD_MN_MSG_SM_MDDB_DETACH which is used to detach mddbs.
 *
 * Used when running:
 *	metadb -s set_name -d
 * 	metaset -s set_name -a/-d disk
 *	metaset -s set_name -b
 */
/*ARGSUSED*/
void
mdmn_do_sm_mddb_detach(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_meta_db_detach_t	*d;
	struct mddb_config		c;
	int				i;
	int				ret = 0;
	md_error_t			ep = mdnullerror;
	char				*name, *del_name;
	mdname_t			*np;
	mdsetname_t			*sp;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_meta_db_detach_t *)((void *)(msg->msg_event_data));

	if ((sp = metasetnosetname(msg->msg_setno, &ep)) == NULL) {
		(void) mdstealerror(&(resp->mmr_ep), &ep);
		resp->mmr_exitval = -1;
		return;
	}

	(void) memset(&c, 0, sizeof (c));
	c.c_setno = msg->msg_setno;
	if (metaioctl(MD_DB_GETDEV, &c, &c.c_mde, NULL) != 0) {
		resp->mmr_exitval = -1;
		(void) mdstealerror(&(resp->mmr_ep), &c.c_mde);
		return;
	}
	i = 0;
	del_name = splicename(&d->msg_splitname);
	while (i < c.c_dbcnt) {
		c.c_id = i;
		if (metaioctl(MD_DB_GETDEV, &c, &c.c_mde, NULL) != 0) {
			ret = -1;
			(void) mdstealerror(&(resp->mmr_ep), &c.c_mde);
			break;
		}
		name = splicename(&c.c_devname);
		if (strcmp(name, del_name) != 0) {
			Free(name);
			i++;
			continue;
		}
		Free(name);
		/* Found a match - delete mddb */
		if (metaioctl(MD_DB_DELDEV, &c, &c.c_mde, NULL) != 0) {
			ret = -1;
			(void) mdstealerror(&(resp->mmr_ep), &c.c_mde);
			break;
		}
		/* Not incrementing "i" intentionally (dbcnt is changed) */
	}
	if ((np = metaname(&sp, del_name, LOGICAL_DEVICE, &ep)) != NULL) {
		meta_invalidate_name(np);
	} else {
		ret = -1;
		(void) mdstealerror(&(resp->mmr_ep), &ep);
	}
	Free(del_name);

	resp->mmr_exitval = ret;
}

/*
 * Handler for MD_MN_MSG_META_DB_NEWSIDE which is used to update the
 * side information for each diskset mddb when a new host has been
 * added to the diskset.  The side information is the /dev/dsk/ctds name
 * that the new node would use to access each mddb.
 *
 * Since this routine makes no changes to the records in the diskset mddb,
 * this routine only needs to be run on the master node.  The master node's
 * kernel code will detect that portions of the mddb have changed and
 * will send a parse message to all nodes to re-parse parts of the mddb.
 *
 * Used when running:
 * 	metaset -s set_name -a -h new_hostname
 */
/*ARGSUSED*/
void
mdmn_do_meta_db_newside(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_meta_db_newside_t	*d;
	struct mddb_config		c;
	int				ret = 0;
	mdsetname_t			*sp;
	md_error_t			ep = mdnullerror;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_meta_db_newside_t *)((void *)(msg->msg_event_data));

	(void) memset(&c, 0, sizeof (c));
	c.c_setno = msg->msg_setno;
	c.c_locator.l_dev = meta_cmpldev(d->msg_l_dev);
	c.c_locator.l_blkno = d->msg_blkno;
	(void) strncpy(c.c_locator.l_driver, d->msg_dname,
	    sizeof (c.c_locator.l_driver));
	c.c_devname = d->msg_splitname;
	c.c_locator.l_mnum = d->msg_mnum;
	c.c_multi_node = 1;
	if ((sp = metasetnosetname(c.c_setno, &ep)) == NULL) {
		(void) mdstealerror(&(resp->mmr_ep), &ep);
		resp->mmr_exitval = -1;
		return;
	}
	(void) strcpy(c.c_setname, sp->setname);
	c.c_sideno = d->msg_sideno;

	if ((ret = metaioctl(MD_DB_NEWSIDE, &c, &c.c_mde, NULL)) != 0) {
		(void) mdstealerror(&(resp->mmr_ep), &c.c_mde);
	}
	resp->mmr_exitval = ret;
}

/*
 * Handler for MD_MN_MSG_META_DB_DELSIDE which is used to remove the
 * side information for each diskset mddb when a host has been
 * deleted from the diskset.  The side information is the /dev/dsk/ctds name
 * that the node would use to access each mddb.
 *
 * Since this routine makes no changes to the records in the diskset mddb,
 * this routine only needs to be run on the master node.  The master node's
 * kernel code will detect that portions of the mddb have changed and
 * will send a parse message to all nodes to re-parse parts of the mddb.
 *
 * Used when running:
 * 	metaset -s set_name -d -h hostname
 */
/*ARGSUSED*/
void
mdmn_do_meta_db_delside(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_meta_db_delside_t	*d;
	mddb_config_t			c;
	int				ret = 0;
	mdsetname_t			*sp;
	md_error_t			ep = mdnullerror;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_meta_db_delside_t *)((void *)(msg->msg_event_data));

	(void) memset(&c, 0, sizeof (c));
	c.c_setno = msg->msg_setno;
	c.c_locator.l_dev = meta_cmpldev(d->msg_l_dev);
	c.c_locator.l_blkno = d->msg_blkno;
	c.c_multi_node = 1;
	if ((sp = metasetnosetname(c.c_setno, &ep)) == NULL) {
		(void) mdstealerror(&(resp->mmr_ep), &ep);
		resp->mmr_exitval = -1;
		return;
	}
	(void) strcpy(c.c_setname, sp->setname);
	c.c_sideno = d->msg_sideno;

	if ((ret = metaioctl(MD_DB_DELSIDE, &c, &c.c_mde, NULL)) != 0) {
		(void) mdstealerror(&(resp->mmr_ep), &c.c_mde);
	}
	resp->mmr_exitval = ret;
}

/*
 * Handler for MD_MN_MSG_META_MD_ADDSIDE which is used to add the
 * side information for each diskset metadevice component (if that
 * component is a disk) when a host has been added to the diskset.
 * The side information is the /dev/dsk/ctds name that the node would
 * use to access the metadevice component.
 *
 * This routine makes changes to the mddb records and must be run
 * on all nodes.
 *
 * Used when running:
 * 	metaset -s set_name -a -h new_hostname
 */
/*ARGSUSED*/
void
mdmn_do_meta_md_addside(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_meta_md_addside_t	*d;
	mdnm_params_t			nm;
	mdsetname_t			*sp;
	char				*cname, *dname;
	minor_t				mnum;
	int				done, i;
	md_error_t			ep = mdnullerror;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_meta_md_addside_t *)((void *)(msg->msg_event_data));

	(void) memset(&nm, 0, sizeof (nm));
	if ((sp = metasetnosetname(msg->msg_setno, &ep)) == NULL) {
		(void) mdstealerror(&(resp->mmr_ep), &ep);
		resp->mmr_exitval = -1;
		return;
	}
	/* While loop continues until IOCNXTKEY_NM gives nm.key of KEYWILD */
	/*CONSTCOND*/
	while (1) {
		char	*drvnm = NULL;

		nm.mde = mdnullerror;
		nm.setno = msg->msg_setno;
		nm.side = d->msg_otherside;
		if (metaioctl(MD_IOCNXTKEY_NM, &nm, &nm.mde, NULL) != 0) {
			(void) mdstealerror(&(resp->mmr_ep), &nm.mde);
			resp->mmr_exitval = -1;
			return;
		}

		/* Normal exit path is to eventually get a KEYWILD */
		if (nm.key == MD_KEYWILD) {
			resp->mmr_exitval = 0;
			return;
		}

		/*
		 * Okay we have a valid key
		 * Let's see if it is hsp or not
		 */
		nm.devname = (uintptr_t)meta_getnmentbykey(msg->msg_setno,
		    d->msg_otherside, nm.key, &drvnm, NULL, NULL, &ep);
		if (nm.devname == NULL || drvnm == NULL) {
			if (nm.devname)
				Free((void *)(uintptr_t)nm.devname);
			if (drvnm)
				Free((void *)(uintptr_t)drvnm);
			(void) mdstealerror(&(resp->mmr_ep), &ep);
			resp->mmr_exitval = -1;
			return;
		}

		/*
		 * If it is hsp add here
		 */
		if (strcmp(drvnm, MD_HOTSPARES) == 0) {
			if (add_name(sp, d->msg_sideno, nm.key, MD_HOTSPARES,
			    minor(NODEV), (char *)(uintptr_t)nm.devname,
			    NULL, NULL, &ep) == -1) {
				Free((void *)(uintptr_t)nm.devname);
				Free((void *)(uintptr_t)drvnm);
				(void) mdstealerror(&(resp->mmr_ep), &ep);
				resp->mmr_exitval = -1;
				return;
			} else {
				Free((void *)(uintptr_t)nm.devname);
				Free((void *)(uintptr_t)drvnm);
				continue;
			}
		}

		nm.side = d->msg_sideno;
		if ((done = meta_getside_devinfo(sp,
		    (char *)(uintptr_t)nm.devname,
		    d->msg_sideno, &cname, &dname, &mnum, &ep)) == -1) {
			(void) mdstealerror(&(resp->mmr_ep), &ep);
			Free((void *)(uintptr_t)nm.devname);
			resp->mmr_exitval = -1;
			return;
		}

		Free((void *)(uintptr_t)nm.devname);
		Free((void *)(uintptr_t)drvnm);

		if (done != 1) {
			Free(cname);
			Free(dname);
			resp->mmr_exitval = -1;
			return;
		}

		/*
		 * The device reference count can be greater than 1 if
		 * more than one softpart is configured on top of the
		 * same device.  If this is the case then we want to
		 * increment the count to sync up with the other sides.
		 */
		for (i = 0; i < nm.ref_count; i++) {
			if (add_name(sp, d->msg_sideno, nm.key, dname, mnum,
			    cname, NULL, NULL, &ep) == -1) {
				(void) mdstealerror(&(resp->mmr_ep), &ep);
				Free(cname);
				Free(dname);
				resp->mmr_exitval = -1;
				return;
			}
		}
		Free(cname);
		Free(dname);
	}

	/*NOTREACHED*/
}
/*
 * Handler for MD_MN_MSG_META_MD_DELSIDE which is used to delete the
 * side information for each diskset metadevice component (if that
 * component is a disk) when a host has been removed from the diskset.
 * The side information is the /dev/dsk/ctds name that the node would
 * use to access the metadevice component.
 *
 * This routine makes changes to the mddb records and must be run
 * on all nodes.
 *
 * Used when running:
 * 	metaset -s set_name -d -h hostname
 */
/*ARGSUSED*/
void
mdmn_do_meta_md_delside(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_meta_md_delside_t	*d;
	mdnm_params_t			nm;
	mdsetname_t			*sp;
	md_error_t			ep = mdnullerror;
	int				i;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_meta_md_delside_t *)((void *)(msg->msg_event_data));

	if ((sp = metasetnosetname(msg->msg_setno, &ep)) == NULL) {
		(void) mdstealerror(&(resp->mmr_ep), &ep);
		resp->mmr_exitval = -1;
		return;
	}

	(void) memset(&nm, 0, sizeof (nm));
	nm.key = MD_KEYWILD;
	/*CONSTCOND*/
	while (1) {
		nm.mde = mdnullerror;
		nm.setno = msg->msg_setno;
		nm.side = MD_SIDEWILD;
		if (metaioctl(MD_IOCNXTKEY_NM, &nm, &nm.mde, NULL) != 0) {
			(void) mdstealerror(&(resp->mmr_ep), &nm.mde);
			resp->mmr_exitval = -1;
			return;
		}

		/* Normal exit path is to eventually get a KEYWILD */
		if (nm.key == MD_KEYWILD) {
			resp->mmr_exitval = 0;
			return;
		}

		/*
		 * The device reference count can be greater than 1 if
		 * more than one softpart is configured on top of the
		 * same device.  If this is the case then we want to
		 * decrement the count to zero so the entry can be
		 * actually removed.
		 */
		for (i = 0; i < nm.ref_count; i++) {
			if (del_name(sp, d->msg_sideno, nm.key, &ep) == -1) {
				(void) mdstealerror(&(resp->mmr_ep), &ep);
				resp->mmr_exitval = -1;
				return;
			}
		}
	}

	/*NOTREACHED*/
}

/*
 * Handler for MD_MN_MSG_MDDB_OPTRECERR which is used to notify
 * the master node that a node has seen an error when attempting to
 * write to the optimized resync records that reside on 2 of the diskset
 * mddbs.  Master node will mark the failed replica in error and this
 * will send a parse message to all nodes to re-read parts of the mddb
 * and to fix their optimized resync records based on this information.
 */
/*ARGSUSED*/
void
mdmn_do_mddb_optrecerr(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_mddb_optrecerr_t	*d;
	mddb_optrec_parm_t		mop;
	int				ret;
	int				i;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_mddb_optrecerr_t *)((void *)(msg->msg_event_data));

	(void) memset(&mop, 0, sizeof (mop));
	mop.c_setno = msg->msg_setno;
	for (i = 0; i < 2; i++) {
		mop.c_recerr[i] = d->msg_recerr[i];
	}
	ret = metaioctl(MD_MN_MDDB_OPTRECFIX, &mop, &mop.c_mde, NULL);
	if (ret)
		(void) mdstealerror(&(resp->mmr_ep), &mop.c_mde);

	resp->mmr_exitval = ret;
}

int
mdmn_smgen_test6(md_mn_msg_t *msg, md_mn_msg_t **msglist)
{
	md_mn_msg_t	*nmsg;

	nmsg = Zalloc(sizeof (md_mn_msg_t));
	MSGID_COPY(&(msg->msg_msgid), &(nmsg->msg_msgid));

	nmsg->msg_flags		= MD_MSGF_NO_LOG; /* Don't log submessages */
	nmsg->msg_setno		= msg->msg_setno;
	nmsg->msg_type		= MD_MN_MSG_TEST2;
	nmsg->msg_event_size	= sizeof ("test2");
	nmsg->msg_event_data	= Strdup("test2");
	msglist[0] = nmsg;

	nmsg = Zalloc(sizeof (md_mn_msg_t));
	MSGID_COPY(&(msg->msg_msgid), &(nmsg->msg_msgid));

	nmsg->msg_flags		= MD_MSGF_NO_LOG; /* Don't log submessages */
	nmsg->msg_setno		= msg->msg_setno;
	nmsg->msg_type		= MD_MN_MSG_TEST2;
	nmsg->msg_event_size	= sizeof ("test2");
	nmsg->msg_event_data	= Strdup("test2");
	msglist[1] = nmsg;

	nmsg = Zalloc(sizeof (md_mn_msg_t));
	MSGID_COPY(&(msg->msg_msgid), &(nmsg->msg_msgid));

	nmsg->msg_flags		= MD_MSGF_NO_LOG; /* Don't log submessages */
	nmsg->msg_setno		= msg->msg_setno;
	nmsg->msg_type		= MD_MN_MSG_TEST3;
	nmsg->msg_event_size	= sizeof ("test3");
	nmsg->msg_event_data	= Strdup("test3");
	msglist[2] = nmsg;

	nmsg = Zalloc(sizeof (md_mn_msg_t));
	MSGID_COPY(&(msg->msg_msgid), &(nmsg->msg_msgid));

	nmsg->msg_flags		= MD_MSGF_NO_LOG; /* Don't log submessages */
	nmsg->msg_setno		= msg->msg_setno;
	nmsg->msg_type		= MD_MN_MSG_TEST4;
	nmsg->msg_event_size	= sizeof ("test4");
	nmsg->msg_event_data	= Strdup("test4");
	msglist[3] = nmsg;

	return (4); /* Return the number of submessages generated */
}

/*
 * This is to send an MD_IOCSET ioctl to all nodes to create a soft
 * partition.
 */
/*ARGSUSED*/
void
mdmn_do_iocset(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_iocset_t	*d;
	int			ret;
	set_t			setno;
	mdsetname_t		*sp;
	mdname_t		*np;
	md_error_t		mde = mdnullerror;

	resp->mmr_comm_state = MDMNE_ACK; /* Ok state */;
	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	d = (md_mn_msg_iocset_t *)(void *)msg->msg_event_data;

	setno = MD_MIN2SET(d->iocset_params.mnum);
	if ((sp = metasetnosetname(setno, &mde)) == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_MSG_IOCSET: Invalid setno %d\n"), setno);
		resp->mmr_exitval = 1;
		return;
	}

	/*
	 * Device should be in the namespace already
	 */
	if ((np = metamnumname(&sp, d->iocset_params.mnum, 1, &mde)) == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_MSG_IOCSET: Invalid mnum %d\n"),
		    d->iocset_params.mnum);
		resp->mmr_exitval = 1;
		return;
	}

	/*
	 * Create unit structure
	 */
	d->iocset_params.mdp = (uintptr_t)&d->unit; /* set pointer to unit */
	ret = metaioctl(MD_IOCSET, &(d->iocset_params), &mde, np->cname);
	resp->mmr_exitval = ret;
}

/*
 * This is to update the status of a softpart
 */
/*ARGSUSED*/
void
mdmn_do_sp_setstat(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_sp_setstat_t	*d;
	int			ret;
	set_t			setno;
	mdsetname_t		*sp;
	minor_t			mnum;
	md_error_t		mde = mdnullerror;

	resp->mmr_comm_state = MDMNE_ACK; /* Ok state */;
	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	d = (md_mn_msg_sp_setstat_t *)(void *)msg->msg_event_data;

	mnum = d->sp_setstat_mnum;
	setno = MD_MIN2SET(mnum);
	if ((sp = metasetnosetname(setno, &mde)) == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_MSG_IOCSET: Invalid setno %d\n"), setno);
		resp->mmr_exitval = 1;
		return;
	}

	ret = meta_sp_setstatus(sp, &mnum, 1, d->sp_setstat_status, &mde);
	resp->mmr_exitval = ret;
}

/*
 * This is to add a key to the namespace
 */
/*ARGSUSED*/
void
mdmn_do_addkeyname(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_addkeyname_t	*d;
	int			ret;
	set_t			setno;
	mdsetname_t		*sp;
	md_error_t		mde = mdnullerror;
	mdname_t		*compnp;

	resp->mmr_comm_state = MDMNE_ACK; /* Ok state */;
	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	d = (md_mn_msg_addkeyname_t *)(void *)msg->msg_event_data;

	setno = d->addkeyname_setno;
	if ((sp = metasetnosetname(setno, &mde)) == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_ADDKEYNAME: Invalid setno %d\n"), setno);
		resp->mmr_exitval = -1;
		return;
	}

	compnp = metaname(&sp, d->addkeyname_name, UNKNOWN, &mde);
	if (compnp != NULL) {
		ret = add_key_name(sp, compnp, NULL, &mde);
		if (ret < 0)
			resp->mmr_exitval = -1;
		else
			resp->mmr_exitval = compnp->key;
	} else {
		resp->mmr_exitval = -1;
	}
}

/*
 * This is to delete a key from the namespace
 */
/*ARGSUSED*/
void
mdmn_do_delkeyname(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_delkeyname_t	*d;
	int			ret;
	set_t			setno;
	mdsetname_t		*sp;
	md_error_t		mde = mdnullerror;
	mdname_t		*compnp;

	resp->mmr_comm_state = MDMNE_ACK; /* Ok state */;
	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	d = (md_mn_msg_delkeyname_t *)(void *)msg->msg_event_data;

	setno = d->delkeyname_setno;
	if ((sp = metasetnosetname(setno, &mde)) == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_DELKEYNAME: Invalid setno %d\n"), setno);
		resp->mmr_exitval = -1;
		return;
	}

	compnp = metadevname(&sp, d->delkeyname_dev, &mde);
	if (compnp != NULL) {
		/*
		 * Reset the key value for the name. This is required because
		 * any previous call of del_key_name for the same component
		 * will have resulted in the key value being reset to MD_KEYBAD
		 * even though there may still be references to this component.
		 */
		compnp->key = d->delkeyname_key;
		ret = del_key_name(sp, compnp, &mde);
		resp->mmr_exitval = ret;
	} else {
		resp->mmr_exitval = -1;
	}
}

/*
 * This is to get the value of tstate from the master node. We use this
 * to get the ABR state of a metadevice from the master.
 */
/*ARGSUSED*/
void
mdmn_do_get_tstate(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_gettstate_t	*d;
	int			ret;
	uint_t			tstate;
	md_error_t		mde = mdnullerror;

	resp->mmr_comm_state = MDMNE_ACK; /* Ok state */;
	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	d = (md_mn_msg_gettstate_t *)(void *)msg->msg_event_data;

	ret = meta_get_tstate(d->gettstate_dev, &tstate, &mde);
	if (ret != 0) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_GET_TSTATE: Invalid dev %llx\n"), d->gettstate_dev);
		tstate = 0;
	}
	resp->mmr_exitval = tstate;
}

/*
 * This is to get the mirror ABR state and the state of its submirrors from
 * the master node. We need this to ensure consistent output from metastat
 * when a new node joins the cluster during a resync. Without this the
 * submirror status will be incorrect until the whole resync is complete which
 * may take days for very large metadevices.
 */
/*ARGSUSED*/
void
mdmn_do_get_mirstate(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_mir_state_t		*d;
	md_mn_msg_mir_state_res_t	*res;		/* Results */
	set_t				setno;
	mdsetname_t			*sp;		/* Set name */
	mdname_t			*mirnp;		/* Mirror name */
	md_error_t			mde = mdnullerror;
	mm_unit_t			*mm;		/* Mirror */
	int				smi;
	uint_t				tstate;

	resp->mmr_comm_state = MDMNE_ACK;
	resp->mmr_out_size = sizeof (md_mn_msg_mir_state_res_t);
	resp->mmr_err_size = 0;
	resp->mmr_out = Malloc(resp->mmr_out_size);
	resp->mmr_err = NULL;
	d = (md_mn_msg_mir_state_t *)(void *)msg->msg_event_data;
	res = (md_mn_msg_mir_state_res_t *)(void *)resp->mmr_out;

	/* Validate set information from minor number */
	setno = MD_MIN2SET(d->mir_state_mnum);
	sp = metasetnosetname(setno, &mde);
	if (sp == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_GET_MIRROR_STATE: Invalid set %d\n"), setno);
		resp->mmr_exitval = 1;	/* Failure */
		Free(resp->mmr_out);
		resp->mmr_out_size = 0;
		return;
	}

	/* Construct mirror name from minor number */
	mirnp = metamnumname(&sp, d->mir_state_mnum, 0, &mde);
	if (mirnp == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_GET_MIRROR_STATE: Invalid minor %lx\n"),
		    d->mir_state_mnum);
		resp->mmr_exitval = 2;	/* Failure */
		Free(resp->mmr_out);
		resp->mmr_out_size = 0;
		return;
	}

	/* Get common mirror structure */
	mm = (mm_unit_t *)meta_get_mdunit(sp, mirnp, &mde);
	if (mm == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_GET_MIRROR_STATE: Invalid mirror minor %x\n"),
		    d->mir_state_mnum);
		resp->mmr_exitval = 3;	/* Failure */
		Free(resp->mmr_out);
		resp->mmr_out_size = 0;
		return;
	}

	if (meta_get_tstate(d->mir_state_mnum, &tstate, &mde) != 0) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_GET_MIRROR_STATE: Invalid minor %lx\n"),
		    d->mir_state_mnum);
		resp->mmr_exitval = 4;	/* Failure */
		Free(resp->mmr_out);
		resp->mmr_out_size = 0;
		return;
	}
	/*
	 * Fill in the sm_state/sm_flags value in the results structure which
	 * gets passed back to the message originator
	 */
	resp->mmr_exitval = 0;
	for (smi = 0; (smi < NMIRROR); smi++) {
		mm_submirror_t *mmsp = &mm->un_sm[smi];
		res->sm_state[smi] = mmsp->sm_state;
		res->sm_flags[smi] = mmsp->sm_flags;
	}
	/* Returm value of tstate for mirror */
	res->mir_tstate = tstate;
}

/*
 * This is to issue an ioctl to call poke_hotspares
 */
/*ARGSUSED*/
void
mdmn_do_poke_hotspares(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{

	md_mn_poke_hotspares_t	pokehsp;
	md_mn_msg_pokehsp_t	*d;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_pokehsp_t *)(void *)msg->msg_event_data;

	(void) memset(&pokehsp, 0, sizeof (pokehsp));
	MD_SETDRIVERNAME(&pokehsp, MD_MIRROR, d->pokehsp_setno);

	resp->mmr_exitval = metaioctl(MD_MN_POKE_HOTSPARES, &pokehsp,
	    &pokehsp.mde, NULL);
}

/*
 * Called to create a softpart during a metarecover operation
 */
/*ARGSUSED*/
void
mdmn_do_addmdname(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_addmdname_t	*d;
	md_error_t		mde = mdnullerror;
	mdsetname_t		*sp;
	int			init = 0;
	mdkey_t			key;
	minor_t			mnum;

	resp->mmr_comm_state = MDMNE_ACK; /* Ok state */;
	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	d = (md_mn_msg_addmdname_t *)(void *)msg->msg_event_data;

	if ((sp = metasetnosetname(d->addmdname_setno, &mde)) == NULL) {
		syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
		    "MD_MN_MSG_ADDMDNAME: Invalid setno %d\n"),
		    d->addmdname_setno);
		resp->mmr_exitval = 1;
		return;
	}

	/*
	 * If device node does not exist then init it
	 */
	if (!is_existing_meta_hsp(sp, d->addmdname_name)) {
		if ((key = meta_init_make_device(&sp, d->addmdname_name,
		    &mde)) <= 0) {
			syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
			    "MD_MN_MSG_ADDMDNAME: Invalid name %s\n"),
			    d->addmdname_name);
			resp->mmr_exitval = 1;
			return;
		}

		init = 1;
	}

	/*
	 * We should have it
	 */
	if (metaname(&sp, d->addmdname_name, META_DEVICE, &mde) == NULL) {

		if (init) {
			if (meta_getnmentbykey(sp->setno, MD_SIDEWILD,
			    key, NULL, &mnum, NULL, &mde) != NULL) {
				(void) metaioctl(
				    MD_IOCREM_DEV, &mnum, &mde, NULL);
			}
		(void) del_self_name(sp, key, &mde);
		}

		resp->mmr_exitval = 1;
		return;
	}

	resp->mmr_exitval = 0;
}

/*
 * This is used to issue a MD_MN_RR_DIRTY ioctl to the mirror.
 */
/*ARGSUSED*/
void
mdmn_do_mark_dirty(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_rr_dirty_t	*d;
	md_mn_rr_dirty_params_t	rp;
	int			ret;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_rr_dirty_t *)((void *)(msg->msg_event_data));

	(void) memset(&rp, 0, sizeof (rp));
	MD_SETDRIVERNAME(&rp, MD_MIRROR, MD_MIN2SET(d->rr_mnum))
	rp.rr_mnum = d->rr_mnum;
	rp.rr_nodeid = d->rr_nodeid;
	rp.rr_start = (ushort_t)((d->rr_range >> 16) & 0xffff);
	rp.rr_end = (ushort_t)(d->rr_range & 0xffff);

	ret = metaioctl(MD_MN_RR_DIRTY, &rp, &rp.mde, NULL);

	resp->mmr_exitval = ret;
}

/*
 * This is used to issue a MD_MN_RR_CLEAN ioctl to the mirror.
 */
/*ARGSUSED*/
void
mdmn_do_mark_clean(md_mn_msg_t *msg, uint_t flags, md_mn_result_t *resp)
{
	md_mn_msg_rr_clean_t	*d;
	md_mn_rr_clean_params_t	*rcp;
	int			ret;

	resp->mmr_out_size = 0;
	resp->mmr_err_size = 0;
	resp->mmr_out = NULL;
	resp->mmr_err = NULL;
	resp->mmr_comm_state = MDMNE_ACK;
	d = (md_mn_msg_rr_clean_t *)((void *)(msg->msg_event_data));

	rcp = Zalloc(sizeof (struct md_mn_rr_clean_params) +
	    MDMN_MSG_RR_CLEAN_DATA_BYTES(d));
	MD_SETDRIVERNAME(rcp, MD_MIRROR, MD_MIN2SET(d->rr_mnum))
	rcp->rr_mnum = d->rr_mnum;
	rcp->rr_nodeid = d->rr_nodeid;
	rcp->rr_start_size = d->rr_start_size;
	(void) memcpy(MDMN_RR_CLEAN_PARAMS_DATA(rcp), MDMN_MSG_RR_CLEAN_DATA(d),
	    MDMN_MSG_RR_CLEAN_DATA_BYTES(d));

	ret = metaioctl(MD_MN_RR_CLEAN, rcp, &rcp->mde, NULL);

	Free(rcp);

	resp->mmr_exitval = ret;
}