xref: /onnv-gate/usr/src/lib/lvm/libmeta/common/meta_metad.c (revision 1945)

/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

/*
 * Just in case we're not in a build environment, make sure that
 * TEXT_DOMAIN gets set to something.
 */
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif

#include <meta.h>
#include <metad.h>
#include <devid.h>

static md_setkey_t	*my_cl_sk = NULL;

#define	CL_DEF_TMO	30L

/*
 * Convert an old style mddrivename_t into a new style
 * mddrivename_t. Meant to be used *ONLY* by rpc.metad
 */
void
meta_conv_drvname_old2new(
	o_mddrivename_t		*v1_dp,
	mddrivename_t		*v2_dp
)
{
	int 		sliceno;
	o_mdname_t	*v1_np;
	mdname_t	*v2_np;

	/* fields that haven't changed */
	v2_dp->cname   = v1_dp->cname;
	v2_dp->rname   = v1_dp->rname;
	v2_dp->type    = v1_dp->type;
	v2_dp->errnum  = v1_dp->errnum;

	/* geometry information */
	v2_dp->geom.ncyl  = v1_dp->geom.ncyl;
	v2_dp->geom.nhead = v1_dp->geom.nhead;
	v2_dp->geom.nsect = v1_dp->geom.nsect;
	v2_dp->geom.rpm   = v1_dp->geom.rpm;
	v2_dp->geom.write_reinstruct = v1_dp->geom.write_reinstruct;
	v2_dp->geom.read_reinstruct  = v1_dp->geom.read_reinstruct;
	v2_dp->geom.blk_sz = 0;

	/* controller information */
	v2_dp->cinfo = v1_dp->cinfo;

	/* vtoc information */
	v2_dp->vtoc.nparts    = v1_dp->vtoc.nparts;
	v2_dp->vtoc.first_lba = 0;
	v2_dp->vtoc.last_lba  = 0;
	v2_dp->vtoc.lbasize   = 0;

	for (sliceno = 0; sliceno < (MD_MAX_PARTS - 1); sliceno++) {
		v2_dp->vtoc.parts[sliceno].start =
		    (diskaddr_t)v1_dp->vtoc.parts[sliceno].start;
		v2_dp->vtoc.parts[sliceno].size =
		    (diskaddr_t)v1_dp->vtoc.parts[sliceno].size;
		v2_dp->vtoc.parts[sliceno].tag =
		    v1_dp->vtoc.parts[sliceno].tag;
		v2_dp->vtoc.parts[sliceno].flag =
		    v1_dp->vtoc.parts[sliceno].flag;
		v2_dp->vtoc.parts[sliceno].label =
		    (diskaddr_t)v1_dp->vtoc.parts[sliceno].label;
	}

	/* The new style vtoc has 17 partitions */
	v2_dp->vtoc.parts[MD_MAX_PARTS - 1].start = 0;
	v2_dp->vtoc.parts[MD_MAX_PARTS - 1].size  = 0;
	v2_dp->vtoc.parts[MD_MAX_PARTS - 1].tag   = 0;
	v2_dp->vtoc.parts[MD_MAX_PARTS - 1].flag  = 0;
	v2_dp->vtoc.parts[MD_MAX_PARTS - 1].label = 0;

	v2_dp->vtoc.typename = v1_dp->vtoc.typename;

	/* partition information */
	v2_dp->parts.parts_len = v1_dp->parts.parts_len;
	for (sliceno = 0; sliceno < v1_dp->parts.parts_len; sliceno++) {
		v1_np = &v1_dp->parts.parts_val[sliceno];
		v2_np = &v2_dp->parts.parts_val[sliceno];

		/*
		 * We speculate that if cname for a particular
		 * partition does not exist, the other fields
		 * don't exist either. In such a case, we don't
		 * need to do anything for that partition.
		 */
		if (v1_np->cname != NULL) {
			v2_np->cname = v1_np->cname;
			v2_np->bname = v1_np->bname;
			v2_np->rname = v1_np->rname;
			v2_np->devicesname = v1_np->devicesname;
			v2_np->dev = meta_expldev(v1_np->dev);
			v2_np->key = v1_np->key;
			v2_np->end_blk = (diskaddr_t)v1_np->end_blk;
			v2_np->start_blk = (diskaddr_t)v1_np->start_blk;
		}
		v2_np->drivenamep = v2_dp;
	}

	/* We don't care about the rest of the fields */
	v2_dp->side_names = v1_dp->side_names;
	v2_dp->side_names_key = v1_dp->side_names_key;
	v2_dp->miscname = v1_dp->miscname;
}

/*
 * Convert a new style mddrivename_t into an old style
 * mddrivename_t. Meant to be used *ONLY* by rpc.metad
 */
void
meta_conv_drvname_new2old(
	o_mddrivename_t		*v1_dp,
	mddrivename_t		*v2_dp
)
{
	int 		sliceno;
	o_mdname_t	*v1_np;
	mdname_t	*v2_np;

	/* fields that haven't changed */
	v1_dp->cname   = v2_dp->cname;
	v1_dp->rname   = v2_dp->rname;
	v1_dp->type    = v2_dp->type;
	v1_dp->errnum  = v2_dp->errnum;

	/* geometry information */
	v1_dp->geom.ncyl  = v2_dp->geom.ncyl;
	v1_dp->geom.nhead = v2_dp->geom.nhead;
	v1_dp->geom.nsect = v2_dp->geom.nsect;
	v1_dp->geom.rpm   = v2_dp->geom.rpm;
	v1_dp->geom.write_reinstruct = v2_dp->geom.write_reinstruct;
	v1_dp->geom.read_reinstruct  = v2_dp->geom.read_reinstruct;

	/* controller information */
	v1_dp->cinfo = v2_dp->cinfo;

	/* vtoc information */
	v1_dp->vtoc.typename = v2_dp->vtoc.typename;
	v1_dp->vtoc.nparts   = v2_dp->vtoc.nparts;

	for (sliceno = 0; sliceno < (MD_MAX_PARTS - 1); sliceno++) {
		v1_dp->vtoc.parts[sliceno].start =
		    (daddr_t)v2_dp->vtoc.parts[sliceno].start;
		v1_dp->vtoc.parts[sliceno].size  =
		    (daddr_t)v2_dp->vtoc.parts[sliceno].size;
		v1_dp->vtoc.parts[sliceno].tag   =
		    v2_dp->vtoc.parts[sliceno].tag;
		v1_dp->vtoc.parts[sliceno].flag  =
		    v2_dp->vtoc.parts[sliceno].flag;
		v1_dp->vtoc.parts[sliceno].label =
		    (daddr_t)v2_dp->vtoc.parts[sliceno].label;
	}

	/* partition information */
	v1_dp->parts.parts_len = v2_dp->parts.parts_len;

	for (sliceno = 0; sliceno < v2_dp->parts.parts_len; sliceno++) {
		v1_np = &v1_dp->parts.parts_val[sliceno];
		v2_np = &v2_dp->parts.parts_val[sliceno];

		/*
		 * We speculate that if cname for a particular
		 * partition does not exist then the rest of
		 * the fields a partition don't exist either.
		 * In such a case, we don't need to do anything
		 * for that partition.
		 */
		if (v2_np->cname != NULL) {
			v1_np->cname = v2_np->cname;
			v1_np->bname = v2_np->bname;
			v1_np->rname = v2_np->rname;
			v1_np->devicesname = v2_np->devicesname;
			v1_np->dev = meta_cmpldev(v2_np->dev);
			v1_np->key = v2_np->key;
			v1_np->end_blk = (daddr_t)v2_np->end_blk;
			v1_np->start_blk = (daddr_t)v2_np->start_blk;
		}
		v1_np->drivenamep = v1_dp;
	}

	/* We don't care about the rest of the fields */
	v1_dp->side_names = v2_dp->side_names;
	v1_dp->side_names_key = v2_dp->side_names_key;
	v1_dp->miscname = v2_dp->miscname;
}

/*
 * Convert an old style md_drive_desc_t into a new style
 * md_drive_desc_t. Meant to be used *ONLY* by rpc.metad
 */
void
meta_conv_drvdesc_old2new(
	o_md_drive_desc		*v1_dd,
	md_drive_desc		*v2_dd
)
{
	md_drive_desc	*dd;
	o_md_drive_desc	*o_dd;

	dd = v2_dd;

	for (o_dd = v1_dd; o_dd != NULL; o_dd = o_dd->dd_next) {
		dd->dd_ctime = o_dd->dd_ctime;
		dd->dd_genid = o_dd->dd_genid;
		dd->dd_flags = o_dd->dd_flags;
		meta_conv_drvname_old2new(o_dd->dd_dnp, dd->dd_dnp);
		dd->dd_dbcnt = o_dd->dd_dbcnt;
		dd->dd_dbsize = o_dd->dd_dbsize;
		dd = dd->dd_next;
	}
}

/*
 * Convert an new style md_drive_desc_t into a old style
 * md_drive_desc_t. Meant to be used *ONLY* by rpc.metad
 */
void
meta_conv_drvdesc_new2old(
	o_md_drive_desc		*v1_dd,
	md_drive_desc		*v2_dd
)
{
	md_drive_desc	*dd;
	o_md_drive_desc	*o_dd;

	o_dd = v1_dd;

	for (dd = v2_dd; dd != NULL; dd = dd->dd_next) {
		o_dd->dd_ctime = dd->dd_ctime;
		o_dd->dd_genid = dd->dd_genid;
		o_dd->dd_flags = dd->dd_flags;
		meta_conv_drvname_new2old(o_dd->dd_dnp, dd->dd_dnp);
		o_dd->dd_dbcnt = dd->dd_dbcnt;
		o_dd->dd_dbsize = dd->dd_dbsize;
		o_dd = o_dd->dd_next;
	}
}

/*
 * Allocate memory for v1 drive descriptor
 * depending upon the number of drives in the
 * v2 drive descriptor
 */
void
alloc_olddrvdesc(
	o_md_drive_desc		**v1_dd,
	md_drive_desc		*v2_dd
)
{
	md_drive_desc	*dd;
	o_md_drive_desc *new, *head;

	head = NULL;

	for (dd = v2_dd; dd != NULL; dd = dd->dd_next) {
		new = Zalloc(sizeof (o_md_drive_desc));
		new->dd_dnp = Zalloc(sizeof (o_mddrivename_t));
		new->dd_dnp->parts.parts_val = Zalloc(sizeof (o_mdname_t) *
		    dd->dd_dnp->parts.parts_len);
		new->dd_next = head;
		head = new;
	}
	*v1_dd = head;
}

/*
 * Allocate memory for v2 drive descriptor
 * depending upon the number of drives in the
 * v1 drive descriptor
 */
void
alloc_newdrvdesc(
	o_md_drive_desc		*v1_dd,
	md_drive_desc		**v2_dd
)
{
	md_drive_desc	*new, *head;
	o_md_drive_desc	*o_dd;

	head = NULL;

	for (o_dd = v1_dd; o_dd != NULL; o_dd = o_dd->dd_next) {
		new = Zalloc(sizeof (md_drive_desc));
		new->dd_dnp = Zalloc(sizeof (mddrivename_t));
		new->dd_dnp->parts.parts_val = Zalloc(sizeof (mdname_t) *
		    o_dd->dd_dnp->parts.parts_len);
		new->dd_next = head;
		head = new;
	}
	*v2_dd = head;
}

void
free_olddrvdesc(
	o_md_drive_desc		*v1_dd
)
{
	o_md_drive_desc	*o_dd, *head;

	head = v1_dd;

	while (head != NULL) {
		o_dd = head;
		head = head->dd_next;
		free(o_dd->dd_dnp->parts.parts_val);
		free(o_dd->dd_dnp);
		free(o_dd);
	}
}

void
free_newdrvdesc(
	md_drive_desc		*v2_dd
)
{
	md_drive_desc	*dd, *head;

	head = v2_dd;

	while (head != NULL) {
		dd = head;
		head = head->dd_next;
		free(dd->dd_dnp->parts.parts_val);
		free(dd->dd_dnp);
		free(dd);
	}
}

/*
 * Return the device id for a given device
 */
char *
meta_get_devid(
	char	*rname
)
{
	ddi_devid_t	devid;
	int		fd;
	char		*enc_devid, *dup_enc_devid = NULL;

	if ((fd = open(rname, O_RDWR | O_NDELAY, 0)) < 0)
		return (NULL);

	if (devid_get(fd, &devid) == -1) {
		(void) close(fd);
		return (NULL);
	}
	(void) close(fd);

	enc_devid = devid_str_encode(devid, NULL);
	devid_free(devid);

	if (enc_devid != NULL) {
		dup_enc_devid = strdup(enc_devid);
		devid_str_free(enc_devid);
	}

	return (dup_enc_devid);
}

/*
 * Add side names for the diskset drive records
 * NOTE: these go into the local set's namespace.
 */
int
clnt_add_drv_sidenms(
	char			*hostname,
	char			*this_host,
	mdsetname_t		*sp,
	md_set_desc		*sd,
	int			node_c,
	char			**node_v,
	md_error_t		*ep
)
{
	CLIENT				*clntp;
	mdrpc_drv_sidenm_args		v1_args;
	mdrpc_drv_sidenm_2_args		v2_args;
	mdrpc_drv_sidenm_2_args_r1	*v21_args;
	mdrpc_generic_res		res;
	int				rval;
	int				version;
	int				i, j;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v1_args, 0, sizeof (v1_args));
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	v21_args = &v2_args.mdrpc_drv_sidenm_2_args_u.rev1;
	v21_args->hostname = this_host;
	v21_args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	v21_args->sp = sp;
	v21_args->sd = sd;
	v21_args->node_v.node_v_len = node_c;
	v21_args->node_v.node_v_val = node_v;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;

		/*
		 * If the server is local, we call the v2 procedure
		 */
		bool = mdrpc_add_drv_sidenms_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */

			v1_args.sd = Zalloc(sizeof (o_md_set_desc));
			alloc_olddrvdesc(&v1_args.sd->sd_drvs, sd->sd_drvs);

			/* build args */
			v1_args.hostname = this_host;
			v1_args.cl_sk = cl_get_setkey(sp->setno, sp->setname);
			v1_args.sp = sp;
			/* set descriptor */
			v1_args.sd->sd_ctime = sd->sd_ctime;
			v1_args.sd->sd_genid = sd->sd_genid;
			v1_args.sd->sd_setno = sd->sd_setno;
			v1_args.sd->sd_flags = sd->sd_flags;
			for (i = 0; i < MD_MAXSIDES; i++) {
				v1_args.sd->sd_isown[i] = sd->sd_isown[i];

				for (j = 0; j < MD_MAX_NODENAME_PLUS_1; j ++)
					v1_args.sd->sd_nodes[i][j] =
					    sd->sd_nodes[i][j];
			}
			v1_args.sd->sd_med = sd->sd_med;
			meta_conv_drvdesc_new2old(v1_args.sd->sd_drvs,
			    sd->sd_drvs);
			v1_args.node_v.node_v_len = node_c;
			v1_args.node_v.node_v_val = node_v;

			rval = mdrpc_add_drv_sidenms_1(&v1_args, &res, clntp);

			free_olddrvdesc(v1_args.sd->sd_drvs);
			free(v1_args.sd);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN,
				    "metad add drive sidenames"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {			/* version 2 */
			rval = mdrpc_add_drv_sidenms_2(&v2_args, &res, clntp);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN,
				    "metad add drive sidenames"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * Adding drives via metaimport to disksets. Some of the drives may
 * not be available so we need more information than the basic clnt_adddrvs
 * offers us.
 */
int
clnt_imp_adddrvs(
	char			*hostname,
	mdsetname_t		*sp,
	md_drive_desc		*dd,
	md_timeval32_t		timestamp,
	ulong_t			genid,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_drives_2_args	v2_args;
	mdrpc_drives_2_args_r1	*v21_args;
	mdrpc_generic_res	res;
	int			rval;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	v21_args = &v2_args.mdrpc_drives_2_args_u.rev1;
	v21_args->sp = sp;
	v21_args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	v21_args->drivedescs = dd;
	v21_args->timestamp = timestamp;
	v21_args->genid = genid;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;

		/*
		 * If the server is local, we call the v1 procedure
		 */
		bool = mdrpc_imp_adddrvs_2(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
			    sp->setno, hostname, NULL, NULL);
			metarpcclose(clntp);
			return (-1);
		} else {
			rval = mdrpc_imp_adddrvs_2(&v2_args, &res, clntp);
			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN,
				    "metad imp add drives"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}


/*
 * Add drives to disksets.
 */
int
clnt_adddrvs(
	char			*hostname,
	mdsetname_t		*sp,
	md_drive_desc		*dd,
	md_timeval32_t		timestamp,
	ulong_t			genid,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_drives_args	v1_args;
	mdrpc_drives_2_args	v2_args;
	mdrpc_drives_2_args_r1	*v21_args;
	mdrpc_generic_res	res;
	int			rval;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v1_args, 0, sizeof (v1_args));
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	v21_args = &v2_args.mdrpc_drives_2_args_u.rev1;
	v21_args->sp = sp;
	v21_args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	v21_args->drivedescs = dd;
	v21_args->timestamp = timestamp;
	v21_args->genid = genid;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;

		/*
		 * If the server is local, we call the v2 procedure
		 */
		bool = mdrpc_adddrvs_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */

			alloc_olddrvdesc(&v1_args.drivedescs, dd);

			/* build args */
			v1_args.sp = sp;
			v1_args.cl_sk = cl_get_setkey(sp->setno, sp->setname);
			meta_conv_drvdesc_new2old(v1_args.drivedescs, dd);
			v1_args.timestamp = timestamp;
			v1_args.genid = genid;

			rval = mdrpc_adddrvs_1(&v1_args, &res, clntp);

			free_olddrvdesc(v1_args.drivedescs);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN, "metad add drives"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {			/* version 2 */
			rval = mdrpc_adddrvs_2(&v2_args, &res, clntp);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN, "metad add drives"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * Add hosts to disksets.
 */
int
clnt_addhosts(
	char			*hostname,
	mdsetname_t		*sp,
	int			node_c,
	char			**node_v,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_host_args		*args;
	mdrpc_host_2_args	v2_args;
	mdrpc_generic_res	res;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_host_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	args->hosts.hosts_len = node_c;
	args->hosts.hosts_val = node_v;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int bool;
		bool = mdrpc_addhosts_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version and invoke
		 * the appropriate version of the remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_addhosts_1(args, &res, clntp) != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad add hosts"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_addhosts_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad add hosts"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * Create disksets.
 */
int
clnt_createset(
	char			*hostname,
	mdsetname_t		*sp,
	md_node_nm_arr_t	nodes,
	md_timeval32_t		timestamp,
	ulong_t			genid,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_createset_args	*args;
	mdrpc_createset_2_args	v2_args;
	mdrpc_generic_res	res;
	int			i;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_createset_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	args->timestamp = timestamp;
	args->genid = genid;
	for (i = 0; i < MD_MAXSIDES; i++)
		(void) strcpy(args->nodes[i], nodes[i]);

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_createset_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version and invoke
		 * the appropriate version of the remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_createset_1(args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad create set"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_createset_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad create set"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * Create MN disksets.
 */
int
clnt_mncreateset(
	char			*hostname,
	mdsetname_t		*sp,
	md_mnnode_desc		*nodelist,
	md_timeval32_t		timestamp,
	ulong_t			genid,
	md_node_nm_t		master_nodenm,
	int			master_nodeid,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_mncreateset_args	*args;
	mdrpc_mncreateset_2_args v2_args;
	mdrpc_generic_res	res;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_mncreateset_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	args->timestamp = timestamp;
	args->genid = genid;
	(void) strlcpy(args->master_nodenm, master_nodenm, MD_MAX_NODENAME);
	args->master_nodeid = master_nodeid;
	args->nodelist = nodelist;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_mncreateset_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
			    sp->setno, hostname, NULL, sp->setname);
			metarpcclose(clntp);
			return (-1);
		} else {
			if (mdrpc_mncreateset_2(&v2_args, &res, clntp)
							!= RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad mncreate set"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * Join MN set
 */
int
clnt_joinset(
	char			*hostname,
	mdsetname_t		*sp,
	int			flags,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_sp_flags_args	*args;
	mdrpc_sp_flags_2_args	v2_args;
	mdrpc_generic_res	res;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_sp_flags_2_args_u.rev1;
	args->sp = sp;
	args->flags = flags;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_joinset_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
			    sp->setno, hostname, NULL, sp->setname);
			metarpcclose(clntp);
			return (-1);
		} else {
			if (mdrpc_joinset_2(&v2_args, &res, clntp)
							!= RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN, "metad join set"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * Withdraw from MN set
 */
int
clnt_withdrawset(
	char			*hostname,
	mdsetname_t		*sp,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_sp_args		*args;
	mdrpc_sp_2_args		v2_args;
	mdrpc_generic_res	res;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_sp_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_withdrawset_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
			    sp->setno, hostname, NULL, sp->setname);
			metarpcclose(clntp);
			return (-1);
		} else {
			if (mdrpc_withdrawset_2(&v2_args, &res, clntp)
							!= RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN,
				    "metad withdraw set"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * Delete side names for the diskset drive records
 * NOTE: these are removed from the local set's namespace.
 */
int
clnt_del_drv_sidenms(
	char			*hostname,
	mdsetname_t		*sp,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_sp_args		*args;
	mdrpc_sp_2_args		v2_args;
	mdrpc_generic_res	res;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_sp_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_del_drv_sidenms_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		if (metaget_setdesc(sp, ep) == NULL) {
			if (! mdisok(ep))
				return (-1);
			mdclrerror(ep);
		}

		/*
		 * Check the client handle for the version and invoke
		 * the appropriate version of the remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_del_drv_sidenms_1(args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN,
				    "metad delete drive sidenames"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_del_drv_sidenms_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN,
				    "metad delete drive sidenames"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * delete drives from the set
 */
int
clnt_deldrvs(
	char			*hostname,
	mdsetname_t		*sp,
	md_drive_desc		*dd,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_drives_args	v1_args;
	mdrpc_drives_2_args	v2_args;
	mdrpc_drives_2_args_r1	*v21_args;
	mdrpc_generic_res	res;
	int			rval;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v1_args, 0, sizeof (v1_args));
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	v21_args = &v2_args.mdrpc_drives_2_args_u.rev1;
	v21_args->sp = sp;
	v21_args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	v21_args->drivedescs = dd;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;

		/*
		 * If the server is local, we call the v2 procedure
		 */
		bool = mdrpc_deldrvs_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */

			alloc_olddrvdesc(&v1_args.drivedescs, dd);

			/* build args */
			v1_args.sp = sp;
			v1_args.cl_sk = cl_get_setkey(sp->setno, sp->setname);
			meta_conv_drvdesc_new2old(v1_args.drivedescs, dd);

			rval = mdrpc_deldrvs_1(&v1_args, &res, clntp);

			free_olddrvdesc(v1_args.drivedescs);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN,
				    "metad delete drives"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {			/* version 2 */
			rval = mdrpc_deldrvs_2(&v2_args, &res, clntp);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN,
				    "metad delete drives"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * delete host(s) from a set.
 */
int
clnt_delhosts(
	char			*hostname,
	mdsetname_t		*sp,
	int			node_c,
	char			**node_v,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_host_args		*args;
	mdrpc_host_2_args	v2_args;
	mdrpc_generic_res	res;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_host_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	args->hosts.hosts_len = node_c;
	args->hosts.hosts_val = node_v;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_delhosts_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_delhosts_1(args, &res, clntp) != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad delete hosts"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_delhosts_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad delete hosts"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * Delete diskset.
 */
int
clnt_delset(
	char			*hostname,
	mdsetname_t		*sp,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_sp_args		*args;
	mdrpc_sp_2_args		v2_args;
	mdrpc_generic_res	res;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_sp_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_delset_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_delset_1(args, &res, clntp) != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad delete set"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_delset_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad delete set"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * return remote device info
 */
int
clnt_devinfo(
	char			*hostname,
	mdsetname_t		*sp,
	mddrivename_t		*dp,
	md_dev64_t		*ret_dev,
	time_t			*ret_timestamp,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_devinfo_args	v1_args;
	mdrpc_devinfo_2_args	v2_args;
	mdrpc_devinfo_2_args_r1	*v21_args;
	mdrpc_devinfo_res	v1_res;
	mdrpc_devinfo_2_res	v2_res;
	int			rval, version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v1_args, 0, sizeof (v1_args));
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&v1_res,  0, sizeof (v1_res));
	(void) memset(&v2_res, 	0, sizeof (v2_res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	v21_args = &v2_args.mdrpc_devinfo_2_args_u.rev1;
	v21_args->sp = sp;
	v21_args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	v21_args->drivenamep = dp;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;

		/*
		 * If the server is local, we call the v2 procedure.
		 */
		bool = mdrpc_devinfo_2_svc(&v2_args, &v2_res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &v1_res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of
		 * the remote procedure.
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			v1_args.drivenamep =
			    Zalloc(sizeof (o_mddrivename_t));
			v1_args.drivenamep->parts.parts_val =
			    Zalloc((sizeof (o_mdname_t)) *
			    dp->parts.parts_len);

			/* build args */
			v1_args.sp = sp;
			v1_args.cl_sk = cl_get_setkey(sp->setno,
			    sp->setname);

			/*
			 * Convert v2 arguments to v1 arguments
			 * before sending over the wire.
			 */
			meta_conv_drvname_new2old(v1_args.drivenamep,
			    v21_args->drivenamep);

			rval = mdrpc_devinfo_1(&v1_args, &v1_res, clntp);

			free(v1_args.drivenamep->parts.parts_val);
			free(v1_args.drivenamep);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN, "metad device info"));
			else
				(void) mdstealerror(ep, &v1_res.status);
		} else {			/* version 2 */
			rval = mdrpc_devinfo_2(&v2_args, &v2_res, clntp);
			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN, "metad device info"));
			else
				(void) mdstealerror(ep, &v2_res.status);
		}

		metarpcclose(clntp);
	}

	if (mdisok(ep)) {
		/* do something with the results */
		rval = 0;

		if (ret_dev != NULL) {
			if (version == METAD_VERSION)
				*ret_dev = meta_expldev(v1_res.dev);
			else
				*ret_dev = v2_res.dev;
		}

		if (ret_timestamp != NULL) {
			if (version == METAD_VERSION)
				*ret_timestamp = v1_res.vtime;
			else
				*ret_timestamp = v2_res.vtime;
		}
	}

	if (version == METAD_VERSION)
		xdr_free(xdr_mdrpc_devinfo_res, (char *)&v1_res);
	else
		xdr_free(xdr_mdrpc_devinfo_2_res, (char *)&v2_res);

	return (rval);
}

/*
 * return remote device info
 */
int
clnt_devid(
	char			*hostname,
	mdsetname_t		*sp,
	mddrivename_t		*dp,
	char			**ret_encdevid,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_devid_args	*args;
	mdrpc_devid_2_args	v2_args;
	mdrpc_devid_res		res;
	int			rval;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_devid_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	args->drivenamep = dp;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;

		/*
		 * If the server is local, we call the v2 procedure.
		 */
		bool = mdrpc_devid_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) {	/* version 1 */
			(void) mddserror(ep, MDE_DS_DRIVENOTONHOST, sp->setno,
			    hostname, dp->cname, sp->setname);
		} else {			/* version 2 */
			rval = mdrpc_devid_2(&v2_args, &res, clntp);

			if (rval != RPC_SUCCESS)
			    (void) mdrpcerror(ep, clntp, hostname,
			    dgettext(TEXT_DOMAIN, "metad devid info"));
			else
			    (void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	if (mdisok(ep)) {
		/* do something with the results */
		rval = 0;

		if (ret_encdevid != NULL)
			*ret_encdevid = strdup(res.enc_devid);

	}

	xdr_free(xdr_mdrpc_devid_res, (char *)&res);

	return (rval);
}

/*
 * Get the device information of a disk on a remote host. The information
 * retrieved is the device's name, the associated driver and the dev_t.
 * The lookup is performed by using the devid of the disk as this is
 * unique to the disk.  The device name on the originating node is passed
 * in.  If that devname is found when doing the devid to namelist translation
 * then that value is used to make the device names as consistent as possible
 * across the nodes.
 *
 * An attempt is made to retrieve this information by calling
 * mdrpc_devinfo_by_devid_name_2_svc.  Locally this call should always
 * succeed.  In the case where a call is made through a CLIENT handle,
 * it is possible that the function hasn't been implemented on the called
 * node.  If this is the case fall back to mdrpc_devinfo_by_devidstr_2_svc.
 *
 * Returns:
 * 	-1 	Error
 * 	ENOTSUP Operation not supported i.e. procedure not supported on
 * 		the remote node
 * 	0	Success
 */
int
clnt_devinfo_by_devid(
	char		*hostname,
	mdsetname_t	*sp,
	char		*devidstr,
	md_dev64_t	*ret_dev,
	char		*orig_devname,
	char		**ret_devname,
	char		**ret_driver,
	md_error_t	*ep
)
{
	CLIENT			*clntp;
	mdrpc_devidstr_args	devid_args;
	mdrpc_devid_name_args	*args;
	mdrpc_devid_name_2_args	v2_args;
	mdrpc_devinfo_2_res	res;
	int			rval;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_devid_name_2_args_u.rev1;
	args->enc_devid = devidstr;
	args->orig_devname = orig_devname;
	args->sp = sp;

	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;

		/*
		 * We are calling this locally so call the function
		 * directly.
		 */
		bool = mdrpc_devinfo_by_devid_name_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {

		/* open connection */
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL) {
			return (-1);
		}

		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) { /* Version 1 */
			metarpcclose(clntp);
			return (ENOTSUP);
		}

		rval = mdrpc_devinfo_by_devid_name_2(&v2_args, &res, clntp);

		if (rval != RPC_SUCCESS) {
			/* try falling back to devidstr_2_svc */
			(void) memset(&devid_args, 0, sizeof (devid_args));
			(void) memset(&res, 0, sizeof (res));

			devid_args.enc_devid = devidstr;
			devid_args.sp = sp;

			rval = mdrpc_devinfo_by_devid_2(
					&devid_args, &res, clntp);

			if (rval != RPC_SUCCESS) {
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN,
				    "metad devinfo by devid"));
			} else {
				(void) mdstealerror(ep, &res.status);
			}
		} else {
			(void) mdstealerror(ep, &res.status);
		}
		metarpcclose(clntp);
	}

	if (mdisok(ep)) {
		rval = 0;
		if (ret_dev != NULL)
			*ret_dev = res.dev;

		if (ret_devname != NULL && res.devname != NULL)
			*ret_devname = Strdup(res.devname);

		if (ret_driver != NULL && res.drivername != NULL)
			*ret_driver = Strdup(res.drivername);
	}

	xdr_free(xdr_mdrpc_devinfo_2_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);

}


/*
 * return status of whether driver is used, mount
 */
int
clnt_drvused(
	char			*hostname,
	mdsetname_t		*sp,
	mddrivename_t		*dp,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_drvused_args	v1_args;
	mdrpc_drvused_2_args	v2_args;
	mdrpc_drvused_2_args_r1	*v21_args;
	mdrpc_generic_res	res;
	int			rval;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v1_args, 0, sizeof (v1_args));
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	v21_args = &v2_args.mdrpc_drvused_2_args_u.rev1;
	v21_args->sp = sp;
	v21_args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	v21_args->drivenamep = dp;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;

		/*
		 * If the server is local, we call the v2 procedure
		 */
		bool = mdrpc_drvused_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		/* open connection */
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			v1_args.drivenamep =
			    Zalloc(sizeof (o_mddrivename_t));
			v1_args.drivenamep->parts.parts_val =
			    Zalloc((sizeof (o_mdname_t)) *
			    dp->parts.parts_len);

			/* build args */
			v1_args.sp = sp;
			v1_args.cl_sk = cl_get_setkey(sp->setno, sp->setname);

			/* Convert v2 args to v1 args */
			meta_conv_drvname_new2old(v1_args.drivenamep,
			    v21_args->drivenamep);

			rval = mdrpc_drvused_1(&v1_args, &res, clntp);

			free(v1_args.drivenamep->parts.parts_val);
			free(v1_args.drivenamep);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN, "metad drive used"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {			/* version 2 */
			rval = mdrpc_drvused_2(&v2_args, &res, clntp);
			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN, "metad drive used"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

void
free_sr(md_set_record *sr)
{
	mdrpc_getset_res	res;
	mdrpc_mngetset_res	mnres;

	if (md_in_daemon)
		return;

	/*
	 * dummy up a result struct, to do a deep free of the (mn)sr.
	 * (A deep free means that the xdr_free code will free the
	 * linked list of drive records for the sr and will also free
	 * the linked list of node records for the mnsr.)
	 */
	if (MD_MNSET_REC(sr)) {
		(void) memset(&mnres, 0, sizeof (mnres));
		mnres.mnsr = (struct md_mnset_record *)sr;
		xdr_free(xdr_mdrpc_mngetset_res, (char *)&mnres);
	} else {
		(void) memset(&res, 0, sizeof (res));
		res.sr = sr;
		xdr_free(xdr_mdrpc_getset_res, (char *)&res);
	}
}

void
short_circuit_getset(
	mdrpc_getset_args	*args,
	mdrpc_getset_res	*res
)
{
	if (args->setname != NULL)
		res->sr = metad_getsetbyname(args->setname, &res->status);
	else
		res->sr = metad_getsetbynum(args->setno, &res->status);
}

void
short_circuit_mngetset(
	mdrpc_getset_args	*args,
	mdrpc_mngetset_res	*res
)
{
	md_set_record		*sr;
	if (args->setname != NULL)
		sr = metad_getsetbyname(args->setname, &res->status);
	else
		sr = metad_getsetbynum(args->setno, &res->status);

	if (MD_MNSET_REC(sr)) {
		res->mnsr = (struct md_mnset_record *)sr;
	} else {
		res->mnsr = NULL;
	}
}

static int
is_auto_take_set(char *setname, set_t setno)
{
	if (setname != NULL)
	    return (metad_isautotakebyname(setname));
	else
	    return (metad_isautotakebynum(setno));
}

/*
 * return the diskset record, and drive records.
 * If record is a MNdiskset record, then only the first md_set_record
 * bytes were copied from the daemon.
 */
int
clnt_getset(
	char			*hostname,
	char			*setname,
	set_t			setno,
	md_set_record		**ret_sr,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_getset_args	*args;
	mdrpc_getset_2_args	v2_args;
	mdrpc_getset_res	res;
	int			rval = -1;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_getset_2_args_u.rev1;
	args->setname = setname;
	args->setno   = setno;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		short_circuit_getset(args, &res);
		(void) mdstealerror(ep, &res.status);
	} else {
	    if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL) {
		/*
		 * This has to work during the boot up before the rpc.metad can
		 * run.  Check to see if we can handle this as a strictly local
		 * diskset.
		 */
		if (is_auto_take_set(setname, setno)) {
		    mdclrerror(ep);
		    short_circuit_getset(args, &res);
		    res.sr = setdup(res.sr);
		    (void) mdstealerror(ep, &res.status);
		} else {
		    return (-1);
		}
	    } else {

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_getset_1(args, &res, clntp) != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad get set"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_getset_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad get set"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	    }
	}

	if (mdisok(ep)) {
		rval = 0;
		if (ret_sr != NULL)
			*ret_sr = res.sr;
		else
			if (! md_in_daemon)
				xdr_free(xdr_mdrpc_getset_res, (char *)&res);
	}

	return (rval);
}

/*
 * return the multi-node diskset record, drive records and node records.
 */
int
clnt_mngetset(
	char			*hostname,
	char			*setname,
	set_t			setno,
	md_mnset_record		**ret_mnsr,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_getset_args	*args;
	mdrpc_getset_2_args	v2_args;
	mdrpc_mngetset_res	res;
	int			rval = -1;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_getset_2_args_u.rev1;
	args->setname = setname;
	args->setno   = setno;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		short_circuit_mngetset(args, &res);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
				setno, hostname, NULL, setname);
			metarpcclose(clntp);
			return (-1);
		} else {
			if (mdrpc_mngetset_2(&v2_args, &res, clntp)
							!= RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN, "metad mn get set"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	/* If no ep error and no version mismatch - rpc call worked ok */
	if (mdisok(ep)) {
		rval = 0;
		if (ret_mnsr != NULL)
			*ret_mnsr = res.mnsr;
		else
			if (! md_in_daemon)
				xdr_free(xdr_mdrpc_mngetset_res, (char *)&res);
	}

	return (rval);
}

/*
 * Set master nodeid and nodename in multi-node set record.
 */
int
clnt_mnsetmaster(
	char			*hostname,
	mdsetname_t		*sp,
	md_node_nm_t		master_nodenm,
	int			master_nodeid,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_mnsetmaster_args	*args;
	mdrpc_mnsetmaster_2_args	v2_args;
	mdrpc_generic_res	res;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_mnsetmaster_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	(void) strlcpy(args->master_nodenm, master_nodenm, MD_MAX_NODENAME);
	args->master_nodeid = master_nodeid;

	/* do it */
	if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
		return (-1);

	/*
	 * Check the client handle for the version
	 */
	CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

	/*
	 * If the client is version 1, return error
	 * otherwise, make the remote procedure call.
	 */
	if (version == METAD_VERSION) { /* version 1 */
		(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
			sp->setno, hostname, NULL, sp->setname);
		metarpcclose(clntp);
		return (-1);
	} else {
		if (mdrpc_mnsetmaster_2(&v2_args, &res, clntp) != RPC_SUCCESS)
			(void) mdrpcerror(ep, clntp, hostname,
			dgettext(TEXT_DOMAIN, "metad multi-owner set master"));
		else
			(void) mdstealerror(ep, &res.status);
	}

	metarpcclose(clntp);

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * Get the MH timeout values.
 */
int
clnt_gtimeout(
	char			*hostname,
	mdsetname_t		*sp,
	mhd_mhiargs_t		*ret_mhiargs,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_sp_args		*args;
	mdrpc_sp_2_args		v2_args;
	mdrpc_gtimeout_res	res;
	int			rval = -1;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_sp_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_gtimeout_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_gtimeout_1(args, &res, clntp) != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad get timeout"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_gtimeout_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad get timeout"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	if (mdisok(ep)) {

		/* do something with the results */
		rval = 0;

		/* copy md_mhiargs_t */
		if (ret_mhiargs != NULL)
			*ret_mhiargs = *res.mhiargsp;
	}

	xdr_free(xdr_mdrpc_gtimeout_res, (char *)&res);

	return (rval);
}

/*
 * get real hostname from remote host
 */
int
clnt_hostname(
	char			*hostname,
	char			**ret_hostname,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_null_args		args;
	mdrpc_hostname_res	res;
	int			rval = -1;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&args, 0, sizeof (args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	args.cl_sk = NULL;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_hostname_1_svc(&args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		if (mdrpc_hostname_1(&args, &res, clntp) != RPC_SUCCESS)
			(void) mdrpcerror(ep, clntp, hostname,
			    dgettext(TEXT_DOMAIN, "metad hostname"));
		else
			(void) mdstealerror(ep, &res.status);

		metarpcclose(clntp);
	}

	if (mdisok(ep)) {
		/* do something with the results */
		rval = 0;

		if (ret_hostname != NULL)
			*ret_hostname = Strdup(res.hostname);
	}

	xdr_free(xdr_mdrpc_hostname_res, (char *)&res);

	return (rval);
}

/*
 * NULLPROC - just returns a response
 */
int
clnt_nullproc(
	char			*hostname,
	md_error_t		*ep
)
{
	CLIENT			*clntp;

	/* initialize */
	mdclrerror(ep);

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_nullproc_1_svc(NULL, ep, NULL);
		assert(bool == TRUE);
	} else {
		if ((clntp = metarpcopen(hostname, CL_DEF_TMO, ep)) == NULL)
			return (-1);

		if (mdrpc_nullproc_1(NULL, ep, clntp) != RPC_SUCCESS)
			(void) mdrpcerror(ep, clntp, hostname,
			    dgettext(TEXT_DOMAIN, "metad nullproc"));

		metarpcclose(clntp);
	}

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * does host own the set?
 */
int
clnt_ownset(
	char			*hostname,
	mdsetname_t		*sp,
	int			*ret_bool,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_sp_args		*args;
	mdrpc_sp_2_args		v2_args;
	mdrpc_bool_res		res;
	int			rval = -1;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_sp_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_ownset_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
	    if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL) {
		/*
		 * This has to work in the code path from libpreen which is
		 * running within fsck before the rpc.metad can run.  Check
		 * to see if we should handle this as an auto-take diskset.
		 */
		if (is_auto_take_set(sp->setname, sp->setno)) {
		    /* Can't call mdrpc_ownset_2_svc since not in daemon */
		    mdclrerror(ep);
		    if (s_ownset(sp->setno, ep))
			res.value = TRUE;
		    else
			res.value = FALSE;
		} else {
		    return (-1);
		}

	    } else {

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_ownset_1(args, &res, clntp) != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad own set"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_ownset_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad own set"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	    }
	}

	if (mdisok(ep)) {
		/* do something with the results */
		rval = 0;

		if (ret_bool != NULL)
			*ret_bool = res.value;
	}

	xdr_free(xdr_mdrpc_bool_res, (char *)&res);

	return (rval);
}

/*
 * Valid set name.
 */
int
clnt_setnameok(
	char			*hostname,
	mdsetname_t		*sp,
	int			*ret_bool,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_sp_args		*args;
	mdrpc_sp_2_args		v2_args;
	mdrpc_bool_res		res;
	int			rval = -1;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_sp_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_setnameok_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_setnameok_1(args, &res, clntp) != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad setname ok"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_setnameok_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad setname ok"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	if (mdisok(ep)) {
		/* do something with the results */
		rval = 0;

		if (ret_bool != NULL)
			*ret_bool = res.value;
	}

	xdr_free(xdr_mdrpc_bool_res, (char *)&res);

	return (rval);
}

/*
 * Is set number in-use?
 */
int
clnt_setnumbusy(
	char			*hostname,
	set_t			setno,
	int			*ret_bool,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_setno_args	*args;
	mdrpc_setno_2_args	v2_args;
	mdrpc_bool_res		res;
	int			rval = -1;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_setno_2_args_u.rev1;
	args->setno = setno;
	args->cl_sk = NULL;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_setnumbusy_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_setnumbusy_1(args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad setnumber busy"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_setnumbusy_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad setnumber busy"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	if (mdisok(ep)) {
		/* do something with the results */
		rval = 0;

		if (ret_bool != NULL)
			*ret_bool = res.value;
	}

	xdr_free(xdr_mdrpc_bool_res, (char *)&res);

	return (rval);
}

/*
 * Set the timeout values used into the drive records.
 */
int
clnt_stimeout(
	char			*hostname,
	mdsetname_t		*sp,
	mhd_mhiargs_t		*mhiargsp,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_stimeout_args	*args;
	mdrpc_stimeout_2_args	v2_args;
	mdrpc_generic_res	res;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_stimeout_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	args->mhiargsp = mhiargsp;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_stimeout_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_stimeout_1(args, &res, clntp) != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad set timeout"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_stimeout_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad set timeout"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * update drive records
 */
int
clnt_upd_dr_dbinfo(
	char			*hostname,
	mdsetname_t		*sp,
	md_drive_desc		*dd,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_drives_args	v1_args;
	mdrpc_drives_2_args	v2_args;
	mdrpc_drives_2_args_r1	*v21_args;
	mdrpc_generic_res	res;
	int			rval;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v1_args, 0, sizeof (v1_args));
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	v21_args = &v2_args.mdrpc_drives_2_args_u.rev1;
	v21_args->sp = sp;
	v21_args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	v21_args->drivedescs = dd;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;

		/*
		 * If the server is local, we call the v2 procedure
		 */
		bool = mdrpc_upd_dr_dbinfo_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */

			alloc_olddrvdesc(&v1_args.drivedescs, dd);

			/* build args */
			v1_args.sp = sp;
			v1_args.cl_sk = cl_get_setkey(sp->setno, sp->setname);
			meta_conv_drvdesc_new2old(v1_args.drivedescs, dd);

			rval = mdrpc_upd_dr_dbinfo_1(&v1_args, &res, clntp);

			free_olddrvdesc(v1_args.drivedescs);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN,
				    "metad update drive dbinfo"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {			/* version 2 */
			rval = mdrpc_upd_dr_dbinfo_2(&v2_args, &res, clntp);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN,
				    "metad update drive dbinfo"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * update dr_flags field of drive record.
 */
int
clnt_upd_dr_flags(
	char			*hostname,
	mdsetname_t		*sp,
	md_drive_desc		*dd,
	uint_t			new_flags,
	md_error_t		*ep
)
{
	CLIENT				*clntp;
	mdrpc_upd_dr_flags_args		v1_args;
	mdrpc_upd_dr_flags_2_args	v2_args;
	mdrpc_upd_dr_flags_2_args_r1	*v21_args;
	mdrpc_generic_res		res;
	int				rval;
	int				version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v1_args, 0, sizeof (v1_args));
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	v21_args = &v2_args.mdrpc_upd_dr_flags_2_args_u.rev1;
	v21_args->sp = sp;
	v21_args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	v21_args->drivedescs = dd;
	v21_args->new_flags = new_flags;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;

		/*
		 * If the server is local, we call the v2 procedure
		 */
		bool = mdrpc_upd_dr_flags_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */

			alloc_olddrvdesc(&v1_args.drivedescs, dd);

			/* build args */
			v1_args.sp = sp;
			v1_args.cl_sk = cl_get_setkey(sp->setno, sp->setname);
			meta_conv_drvdesc_new2old(v1_args.drivedescs, dd);
			v1_args.new_flags = new_flags;

			rval = mdrpc_upd_dr_flags_1(&v1_args, &res, clntp);

			free_olddrvdesc(v1_args.drivedescs);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN,
				    "metad update drive flags"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {			/* version 2 */
			rval = mdrpc_upd_dr_flags_2(&v2_args, &res, clntp);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN,
				    "metad update drive flags"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep)) {
		if (! mdanyrpcerror(ep))
			return (-1);
		if (strcmp(mynode(), hostname) == 0)
			return (-1);
		mdclrerror(ep);
	}

	return (0);
}

/*
 * update set record flags
 * This replaces all of the sr_flags with the new_flags.  It relies on the
 * caller to "do the right thing" to preserve the existing flags that should
 * not be reset.
 */
static int
upd_sr_flags_common(
	char			*hostname,
	mdsetname_t		*sp,
	uint_t			new_flags,
	md_error_t		*ep
)
{
	CLIENT				*clntp;
	mdrpc_upd_sr_flags_args		*args;
	mdrpc_upd_sr_flags_2_args	v2_args;
	mdrpc_generic_res		res;
	int				version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_upd_sr_flags_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);

	args->new_flags = new_flags;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_upd_sr_flags_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_upd_sr_flags_1(args, &res, clntp) !=
			    RPC_SUCCESS)
			    (void) mdrpcerror(ep, clntp, hostname,
			    dgettext(TEXT_DOMAIN, "metad update set flags"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_upd_sr_flags_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
			    (void) mdrpcerror(ep, clntp, hostname,
			    dgettext(TEXT_DOMAIN, "metad update set flags"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep)) {
		if (! mdanyrpcerror(ep))
			return (-1);
		if (strcmp(mynode(), hostname) == 0)
			return (-1);
		mdclrerror(ep);
	}

	return (0);
}

/*
 * Enable bits in the set record flags field.  This just turns on the specified
 * bits and leaves the other bits alone.
 */
int
clnt_enable_sr_flags(
	char			*hostname,
	mdsetname_t		*sp,
	uint_t			flags,
	md_error_t		*ep
)
{
	uint_t		new_flags;
	md_set_desc	*sd;

	mdclrerror(ep);

	/* Get the flags from the current set */
	if ((sd = metaget_setdesc(sp, ep)) == NULL)
		return (-1);

	/* Turn on the specified bits */
	new_flags = (sd->sd_flags | flags);

	/* do it */
	return (upd_sr_flags_common(hostname, sp, new_flags, ep));
}

/*
 * Disable bits in the set record flags field.  This just turns off the
 * specified bits and leaves the other bits alone.
 */
int
clnt_disable_sr_flags(
	char			*hostname,
	mdsetname_t		*sp,
	uint_t			flags,
	md_error_t		*ep
)
{
	uint_t		new_flags;
	md_set_desc	*sd;

	mdclrerror(ep);

	/* Get the flags from the current set */
	if ((sd = metaget_setdesc(sp, ep)) == NULL)
		return (-1);

	/* Turn off the specified bits */
	new_flags = (sd->sd_flags & ~flags);

	/* do it */
	return (upd_sr_flags_common(hostname, sp, new_flags, ep));
}

/*
 * Assign the flags as the new value(s) for the MD_SR_STATE_FLAGS within the
 * set record flags field.  This actually can set any bits but only clears
 * the bits within the MD_SR_STATE_FLAGS subfield and leaves any other
 * bits turned on.  It can be used to clear (state) and set bits all in one
 * rpc call.
 */
int
clnt_upd_sr_flags(
	char			*hostname,
	mdsetname_t		*sp,
	uint_t			flags,
	md_error_t		*ep
)
{
	uint_t		new_flags;
	md_set_desc	*sd;

	mdclrerror(ep);

	/* Get the flags from the current set */
	if ((sd = metaget_setdesc(sp, ep)) == NULL)
		return (-1);

	/* clear the existing state flags */
	sd->sd_flags &= ~MD_SR_STATE_FLAGS;

	/* Or in the new value */
	new_flags = (sd->sd_flags | flags);

	/* do it */
	return (upd_sr_flags_common(hostname, sp, new_flags, ep));
}

md_setkey_t *
cl_get_setkey(set_t setno, char *setname)
{

	if (my_cl_sk == NULL) {
		my_cl_sk = Zalloc(sizeof (md_setkey_t));
		my_cl_sk->sk_setno = setno;
		my_cl_sk->sk_setname = Strdup(setname);
		my_cl_sk->sk_host = Strdup(mynode());
	} else {
		my_cl_sk->sk_setno = setno;
		if (my_cl_sk->sk_setname != NULL)
			Free(my_cl_sk->sk_setname);
		my_cl_sk->sk_setname = Strdup(setname);
	}

	return (my_cl_sk);
}

void
cl_set_setkey(md_setkey_t *cl_sk)
{
	if ((cl_sk != NULL) && (my_cl_sk != NULL)) {
		assert(my_cl_sk->sk_setno == cl_sk->sk_setno);
		assert(strcmp(my_cl_sk->sk_setname, cl_sk->sk_setname) == 0);
		assert(strcmp(my_cl_sk->sk_host, cl_sk->sk_host) == 0);
		my_cl_sk->sk_key = cl_sk->sk_key;
		return;
	}

	if (my_cl_sk != NULL) {
		if (my_cl_sk->sk_setname != NULL)
			Free(my_cl_sk->sk_setname);
		if (my_cl_sk->sk_host != NULL)
			Free(my_cl_sk->sk_host);
		Free(my_cl_sk);
	}

	my_cl_sk = NULL;

	/* get here, if set called before get */
	if (cl_sk != NULL) {
		my_cl_sk = Zalloc(sizeof (md_setkey_t));
		my_cl_sk->sk_host = Strdup(cl_sk->sk_host);
		my_cl_sk->sk_setno = cl_sk->sk_setno;
		my_cl_sk->sk_setname = Strdup(cl_sk->sk_setname);
		my_cl_sk->sk_key = cl_sk->sk_key;
	}
}

/*
 * Unlock the set after operation is complete.
 */
int
clnt_unlock_set(
	char			*hostname,
	md_setkey_t		*cl_sk,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_null_args		args;
	mdrpc_setlock_res	res;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&args, 0, sizeof (args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	args.cl_sk = cl_sk;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_unlock_set_1_svc(&args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		if (mdrpc_unlock_set_1(&args, &res, clntp) != RPC_SUCCESS)
			(void) mdrpcerror(ep, clntp, hostname,
			    dgettext(TEXT_DOMAIN, "metad unlock set"));
		else
			(void) mdstealerror(ep, &res.status);

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_setlock_res, (char *)&res);

	if (! mdisok(ep)) {
		if (! mdanyrpcerror(ep))
			return (-1);
		if (strcmp(mynode(), hostname) == 0)
			return (-1);
		mdclrerror(ep);
	}

	return (0);
}

/*
 * Lock set so that only operators with valid keys are allowed in the daemon.
 */
int
clnt_lock_set(
	char			*hostname,
	mdsetname_t		*sp,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_null_args		args;
	mdrpc_setlock_res	res;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&args, 0, sizeof (args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	args.cl_sk = cl_get_setkey(sp->setno, sp->setname);

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_lock_set_1_svc(&args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		if (mdrpc_lock_set_1(&args, &res, clntp) != RPC_SUCCESS)
			(void) mdrpcerror(ep, clntp, hostname,
			    dgettext(TEXT_DOMAIN, "metad lock set"));
		else
			(void) mdstealerror(ep, &res.status);

		metarpcclose(clntp);
	}

	if (mdisok(ep))
		cl_set_setkey(res.cl_sk);

	xdr_free(xdr_mdrpc_setlock_res, (char *)&res);

	if (! mdisok(ep)) {
		if (! mdanyrpcerror(ep))
			return (-1);
		if (strcmp(mynode(), hostname) == 0)
			return (-1);
		mdclrerror(ep);
	}

	return (0);
}

/*
 * Add mediator hosts to disksets.
 */
int
clnt_updmeds(
	char			*hostname,
	mdsetname_t		*sp,
	md_h_arr_t		*medp,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_updmeds_args	*args;
	mdrpc_updmeds_2_args	v2_args;
	mdrpc_generic_res	res;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_updmeds_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	args->meds = *medp;			/* structure assignment */

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int bool;
		bool = mdrpc_updmeds_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		if (version == METAD_VERSION) {	/* version 1 */
			if (mdrpc_updmeds_1(args, &res, clntp) != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad add hosts"));
			else
				(void) mdstealerror(ep, &res.status);
		} else {
			if (mdrpc_updmeds_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad add hosts"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * update nr_flags field of node records based
 * on given action.
 */
int
clnt_upd_nr_flags(
	char			*hostname,
	mdsetname_t		*sp,
	md_mnnode_desc		*nd,
	uint_t			flag_action,
	uint_t			flags,
	md_error_t		*ep
)
{
	CLIENT				*clntp;
	mdrpc_upd_nr_flags_args		*args;
	mdrpc_upd_nr_flags_2_args	v2_args;
	mdrpc_generic_res		res;
	int				version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_upd_nr_flags_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	args->nodedescs = nd;
	args->flag_action = flag_action;
	args->flags = flags;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_upd_nr_flags_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
				sp->setno, hostname, NULL, sp->setname);
			metarpcclose(clntp);
			return (-1);
		} else {
			if (mdrpc_upd_nr_flags_2(&v2_args, &res, clntp)
							!= RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN,
				    "metad set node flags"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep)) {
		if (! mdanyrpcerror(ep))
			return (-1);
		if (strcmp(mynode(), hostname) == 0)
			return (-1);
		mdclrerror(ep);
	}

	return (0);
}

/*
 * Clear set locks for all MN disksets.
 * Used during reconfig cycle to recover from failed nodes.
 */
int
clnt_clr_mnsetlock(
	char			*hostname,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_null_args		args;
	mdrpc_generic_res	res;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&args, 0, sizeof (args));
	(void) memset(&res, 0, sizeof (res));

	/* do it */
	if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
		return (-1);

	/*
	 * Check the client handle for the version
	 */
	CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

	/*
	 * If the client is version 1, return error
	 * otherwise, make the remote procedure call.
	 */
	if (version == METAD_VERSION) { /* version 1 */
		(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
			NULL, hostname, NULL, NULL);
		metarpcclose(clntp);
		return (-1);
	} else {
		if (mdrpc_clr_mnsetlock_2(&args, &res, clntp) != RPC_SUCCESS)
			(void) mdrpcerror(ep, clntp, hostname,
			    dgettext(TEXT_DOMAIN, "metad clr mnsetlock"));
		else
			(void) mdstealerror(ep, &res.status);
	}

	metarpcclose(clntp);

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * Calls to suspend, resume or reinit the rpc.mdcommd daemon.
 * This allows a node to remotely suspend, reinit and resume the
 * rpc.mdcommd daemon on the given hostname node.  Used by libmeta
 * to lock out class 1 messages (metainit, etc) on all nodes when running
 * metaset and metadb commands on this node.
 *
 * When suspending the commd, the suspend request will fail until all
 * messages have been drained from the rpc.mdcommd.  This routine will
 * spin sending the suspend request until the rpc.mdcommd is drained
 * or until rpc.mdcommd returns a failure other than MDMNE_SET_NOT_DRAINED.
 *
 * Also used to send the rpc.mdcommd daemon a new nodelist by draining all
 * messages from the mdcommd and sending a reinit command to have mdcommd
 * get the new nodelist from rpc.metad.  Used when nodelist is changed
 * during:
 *	- addition or deletion of host from diskset
 *	- join or withdrawal of host from diskset
 *	- addition of first disk to diskset (joins all nodes)
 *	- removal of last disk from diskset (withdraws all nodes)
 */
int
clnt_mdcommdctl(
	char			*hostname,
	int			flag_action,
	mdsetname_t		*sp,
	md_mn_msgclass_t	class,
	uint_t			flags,
	md_error_t		*ep
)
{
	CLIENT				*clntp;
	mdrpc_mdcommdctl_args		*args;
	mdrpc_mdcommdctl_2_args		v2_args;
	mdrpc_generic_res		res;
	int				version;
	int				suspend_spin = 0;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_mdcommdctl_2_args_u.rev1;
	args->flag_action = flag_action;
	args->setno = sp->setno;
	args->class = class;
	args->flags = flags;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		/*
		 * Call v2 procedure directly if rpc.metad on this node is
		 * sending message to itself.
		 */
		if (flag_action == COMMDCTL_SUSPEND) {
			suspend_spin = 1;
			while (suspend_spin) {
				suspend_spin = 0;
				bool = mdrpc_mdcommdctl_2_svc(&v2_args, &res,
					NULL);
				assert(bool == TRUE);
				/*
				 * If set not yet drained, wait a second
				 * and try again.
				 */
				if (mdisdserror(&(res.status),
				    MDE_DS_COMMDCTL_SUSPEND_NYD)) {
					/* Wait a second and try again */
					mdclrerror(&(res.status));
					(void) sleep(1);
					suspend_spin = 1;
				}
			}
		} else {
			bool = mdrpc_mdcommdctl_2_svc(&v2_args, &res, NULL);
			assert(bool == TRUE);
		}
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
				sp->setno, hostname, NULL, sp->setname);
			metarpcclose(clntp);
			return (-1);
		}

		if (flag_action == COMMDCTL_SUSPEND) {
			suspend_spin = 1;
			while (suspend_spin) {
				suspend_spin = 0;
				if (mdrpc_mdcommdctl_2(&v2_args, &res,
				    clntp) != RPC_SUCCESS) {
					(void) mdrpcerror(ep, clntp,
					    hostname,
					    dgettext(TEXT_DOMAIN,
					    "metad commd control"));
				} else {
					/*
					 * If set not yet drained,
					 * wait a second and
					 * and try again.
					 */
					if (mdisdserror(&(res.status),
					    MDE_DS_COMMDCTL_SUSPEND_NYD)) {
						mdclrerror(&(res.status));
						(void) sleep(1);
						suspend_spin = 1;
					} else {
						(void) mdstealerror(ep,
						    &res.status);
					}
				}
			}
		} else {
			if (mdrpc_mdcommdctl_2(&v2_args, &res, clntp)
			    != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN,
				    "metad commd control"));
			else
				(void) mdstealerror(ep, &res.status);
		}
		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep)) {
		if (! mdanyrpcerror(ep))
			return (-1);
		if (strcmp(mynode(), hostname) == 0)
			return (-1);
		mdclrerror(ep);
	}

	return (0);
}

/*
 * Is owner node stale?
 */
int
clnt_mn_is_stale(
	char			*hostname,
	mdsetname_t		*sp,
	int			*ret_bool,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_setno_args	*args;
	mdrpc_setno_2_args	v2_args;
	mdrpc_bool_res		res;
	int			rval = -1;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_setno_2_args_u.rev1;
	args->setno = sp->setno;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		/*
		 * Call v2 procedure directly if rpc.metad on this node is
		 * sending message to itself.
		 */
		bool = mdrpc_mn_is_stale_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
			    sp->setno, hostname, NULL, sp->setname);
			metarpcclose(clntp);
			return (-1);
		} else {
			if (mdrpc_mn_is_stale_2(&v2_args, &res, clntp) !=
			    RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN, "metad mn is stale"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	if (mdisok(ep)) {
		/* do something with the results */
		rval = 0;

		if (ret_bool != NULL)
			*ret_bool = res.value;
	}

	xdr_free(xdr_mdrpc_bool_res, (char *)&res);

	return (rval);
}

/*
 * Free md_drive_desc linked list of drive descriptors that was alloc'd
 * from a call to the RPC routine clnt_getdrivedesc.  Drive descriptors
 * are from another node.
 */
void
free_rem_dd(md_drive_desc *dd)
{
	mdrpc_getdrivedesc_res	res;

	/*
	 * dummy up a result struct, to do a deep free of the dd.
	 * (A deep free means that the xdr_free code will free the
	 * linked list of drive descs.)
	 */
	(void) memset(&res, 0, sizeof (res));
	res.dd = (struct md_drive_desc *)dd;
	xdr_free(xdr_mdrpc_getdrivedesc_res, (char *)&res);
}

/*
 * Get a partially filled in drive desc from remote node.  Used in MN
 * disksets during the reconfig cycle to get the diskset drive
 * information from another host in order to sync up all nodes.
 * Used when the drive record information isn't good enough
 * since the drive record doesn't give the name of
 * the drive, but just a key into that other node's nodespace.
 * Returned drive desc has the drive name filled in but no other strings
 * in the drivename structure.
 *
 * Returns a 0 if RPC was successful, 1 otherwise.
 */
int
clnt_getdrivedesc(
	char			*hostname,
	mdsetname_t		*sp,
	md_drive_desc		**ret_dd,
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_sp_args		*args;
	mdrpc_sp_2_args		v2_args;
	mdrpc_getdrivedesc_res	res;
	int			version;
	int			rval = -1;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_sp_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_getdrivedesc_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
			    sp->setno, hostname, NULL, sp->setname);
			metarpcclose(clntp);
			return (-1);
		} else {
			if (mdrpc_getdrivedesc_2(&v2_args, &res, clntp)
							!= RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN,
				    "metad get drive desc set"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	/* If no ep error and no version mismatch - rpc call worked ok */
	if (mdisok(ep)) {
		rval = 0;
		if (ret_dd != NULL)
			*ret_dd = res.dd;
		else
			xdr_free(xdr_mdrpc_getdrivedesc_res, (char *)&res);
	}

	return (rval);
}

/*
 * update dr_flags field of drive record.
 * Also sync up genid of drive descriptors and make set
 * record and node records match the genid.
 *
 * Returns a 0 if RPC was successful, 1 otherwise.
 */
int
clnt_upd_dr_reconfig(
	char			*hostname,
	mdsetname_t		*sp,
	md_drive_desc		*dd,
	md_error_t		*ep
)
{
	CLIENT				*clntp;
	mdrpc_upd_dr_flags_2_args	v2_args;
	mdrpc_upd_dr_flags_2_args_r1	*v21_args;
	mdrpc_generic_res		res;
	int				rval;
	int				version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	v21_args = &v2_args.mdrpc_upd_dr_flags_2_args_u.rev1;
	v21_args->sp = sp;
	v21_args->drivedescs = dd;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;

		/*
		 * If the server is local, we call the v2 procedure
		 */
		bool = mdrpc_upd_dr_reconfig_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);
		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
				sp->setno, hostname, NULL, sp->setname);
			metarpcclose(clntp);
			return (-1);
		} else {
			rval = mdrpc_upd_dr_reconfig_2(&v2_args, &res, clntp);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN,
				    "metad update drive reconfig"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep)) {
		if (! mdanyrpcerror(ep))
			return (-1);
		if (strcmp(mynode(), hostname) == 0)
			return (-1);
		mdclrerror(ep);
	}

	return (0);
}

/*
 * Reset mirror owner(s) if mirror owner(s) is in the list of
 * node's specified in the array of nodeids.
 * This is called when a node has been deleted or withdrawn
 * from the diskset.
 */
int
clnt_reset_mirror_owner(
	char			*hostname,
	mdsetname_t		*sp,
	int			node_c,
	int			node_id[],
	md_error_t		*ep
)
{
	CLIENT			*clntp;
	mdrpc_nodeid_args	*args;
	mdrpc_nodeid_2_args	v2_args;
	mdrpc_generic_res	res;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_nodeid_2_args_u.rev1;
	args->sp = sp;
	args->cl_sk = cl_get_setkey(sp->setno, sp->setname);
	args->nodeid.nodeid_len = node_c;
	args->nodeid.nodeid_val = &node_id[0];

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		bool = mdrpc_reset_mirror_owner_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 * and invoke the appropriate version of the
		 * remote procedure
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
			    sp->setno, hostname, NULL, sp->setname);
			metarpcclose(clntp);
			return (-1);
		} else {
			if (mdrpc_reset_mirror_owner_2(&v2_args, &res, clntp)
			    != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN,
					"metad reset mirror owner"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep))
		return (-1);

	return (0);
}

/*
 * Call to suspend and resume I/O for given diskset(s).
 * This allows a node to remotely suspend and resume I/O on
 * a MN diskset.  A diskset number of 0 represents all MN disksets.
 */
int
clnt_mn_susp_res_io(
	char			*hostname,
	set_t			setno,
	int			cmd,
	md_error_t		*ep
)
{
	CLIENT					*clntp;
	mdrpc_mn_susp_res_io_args		*args;
	mdrpc_mn_susp_res_io_2_args		v2_args;
	mdrpc_generic_res			res;
	int					version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&v2_args, 0, sizeof (v2_args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	v2_args.rev = MD_METAD_ARGS_REV_1;
	args = &v2_args.mdrpc_mn_susp_res_io_2_args_u.rev1;
	args->susp_res_cmd = cmd;
	args->susp_res_setno = setno;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		/*
		 * Call v2 procedure directly if rpc.metad on this node is
		 * sending message to itself.
		 */
		bool = mdrpc_mn_susp_res_io_2_svc(&v2_args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
			    setno, hostname, NULL, NULL);
			metarpcclose(clntp);
			return (-1);
		} else {
			if (mdrpc_mn_susp_res_io_2(&v2_args, &res, clntp)
							!= RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN,
				    "metad mn_susp_res_io control"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep)) {
		if (! mdanyrpcerror(ep))
			return (-1);
		if (strcmp(mynode(), hostname) == 0)
			return (-1);
		mdclrerror(ep);
	}

	return (0);
}

/*
 * Resnarf the set after the set has been imported
 *
 * We should never be making this procedure call
 * over the wire, it's sole purpose is to snarf
 * the imported set on the localhost.
 */
int
clnt_resnarf_set(
	char		*hostname,
	set_t		setno,
	md_error_t	*ep
)
{
	CLIENT			*clntp;
	mdrpc_setno_2_args	args;
	mdrpc_generic_res	res;
	int			rval = -1;
	int			version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&args, 0, sizeof (args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	args.rev = MD_METAD_ARGS_REV_1;
	args.mdrpc_setno_2_args_u.rev1.setno = setno;
	args.mdrpc_setno_2_args_u.rev1.cl_sk = NULL;

	/* do it */
	if (strcmp(mynode(), hostname) == 0) {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/* Check the client handle for the version */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/* If the client is version 1, return error */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_CANTRESNARF, MD_SET_BAD,
			    mynode(), NULL, NULL);
		} else {
			rval = mdrpc_resnarf_set_2(&args, &res, clntp);

			if (rval != RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				    dgettext(TEXT_DOMAIN, "metad resnarf set"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);

	} else {
		(void) mddserror(ep, MDE_DS_CANTRESNARF, MD_SET_BAD,
		    mynode(), NULL, NULL);
	}

	if (mdisok(ep))
		rval = 0;

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	return (rval);
}

/*
 * Call to start a resync for a given diskset.
 * Used when a node has been added to a diskset.
 * Should be called after rpc.mdcommd is resumed.
 */
int
clnt_mn_mirror_resync_all(
	char			*hostname,
	set_t			setno,
	md_error_t		*ep
)
{
	CLIENT					*clntp;
	mdrpc_setno_2_args			args;
	mdrpc_generic_res			res;
	int					version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&args, 0, sizeof (args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	args.rev = MD_METAD_ARGS_REV_1;
	args.mdrpc_setno_2_args_u.rev1.setno = setno;
	args.mdrpc_setno_2_args_u.rev1.cl_sk = NULL;

	/* do it */
	if (md_in_daemon && strcmp(mynode(), hostname) == 0) {
		int	bool;
		/*
		 * Call v2 procedure directly if rpc.metad on this node is
		 * sending message to itself.
		 */
		bool = mdrpc_mn_mirror_resync_all_2_svc(&args, &res, NULL);
		assert(bool == TRUE);
		(void) mdstealerror(ep, &res.status);
	} else {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
			    setno, hostname, NULL, NULL);
			metarpcclose(clntp);
			return (-1);
		} else {
			if (mdrpc_mn_mirror_resync_all_2(&args, &res, clntp)
							!= RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN,
				    "metad mn_mirror_resync_all"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep)) {
		if (! mdanyrpcerror(ep))
			return (-1);
		if (strcmp(mynode(), hostname) == 0)
			return (-1);
		mdclrerror(ep);
	}

	return (0);
}

/*
 * Call to update the ABR state for all soft partitions.
 * Used when a node has been added to a diskset.
 * Should be called after rpc.mdcommd is resumed.
 */
int
clnt_mn_sp_update_abr(
	char			*hostname,
	set_t			setno,
	md_error_t		*ep
)
{
	CLIENT					*clntp;
	mdrpc_setno_2_args			args;
	mdrpc_generic_res			res;
	int					version;

	/* initialize */
	mdclrerror(ep);
	(void) memset(&args, 0, sizeof (args));
	(void) memset(&res, 0, sizeof (res));

	/* build args */
	args.rev = MD_METAD_ARGS_REV_1;
	args.mdrpc_setno_2_args_u.rev1.setno = setno;
	args.mdrpc_setno_2_args_u.rev1.cl_sk = NULL;

	/*
	 * No need to call function if adding local node as ABR cannot
	 * be set.
	 */
	if (strcmp(mynode(), hostname) != 0) {
		if ((clntp = metarpcopen(hostname, CL_LONG_TMO, ep)) == NULL)
			return (-1);

		/*
		 * Check the client handle for the version
		 */
		CLNT_CONTROL(clntp, CLGET_VERS, (char *)&version);

		/*
		 * If the client is version 1, return error
		 * otherwise, make the remote procedure call.
		 */
		if (version == METAD_VERSION) { /* version 1 */
			(void) mddserror(ep, MDE_DS_RPCVERSMISMATCH,
			    setno, hostname, NULL, NULL);
			metarpcclose(clntp);
			return (-1);
		} else {
			if (mdrpc_mn_sp_update_abr_2(&args, &res, clntp)
							!= RPC_SUCCESS)
				(void) mdrpcerror(ep, clntp, hostname,
				dgettext(TEXT_DOMAIN,
				    "metad mn_sp_update_abr"));
			else
				(void) mdstealerror(ep, &res.status);
		}

		metarpcclose(clntp);
	}

	xdr_free(xdr_mdrpc_generic_res, (char *)&res);

	if (! mdisok(ep)) {
		if (! mdanyrpcerror(ep))
			return (-1);
		mdclrerror(ep);
	}

	return (0);
}