/*
 * 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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <dlfcn.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <synch.h>
#include <thread.h>
#include <unistd.h>
#include <utility.h>
#include <sys/mdesc.h>
#include <sys/mdesc_impl.h>
#include <sys/debug.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/utsname.h>

#include "ldma.h"
#include "libds.h"
#include "libv12n.h"

/*
 * sun4 support for libv12n.
 *
 * Non-sun4v support is minimal.  The v12n_capabilities() function will
 * only return 0 (not supported, not enabled, no implementation).
 *
 * For sun4v the support for v12n_capabilities(), v12n_domain_roles(),
 * v12n_domain_name() and v12n_domain_uuid() are supported by scanning the
 * MD from /dev/mdesc for specific properties.  For v12n_ctrl_domain() and
 * v12n_chassis_serialno(), the ldoms agent daemon (ldmad) on the control
 * domain supplies the required information via the "agent-system" domain
 * service.
 */

/* libds statics */
static void *v12n_ds_dlhdl = NULL;
static int (*v12n_ds_send_msg)(ds_hdl_t, void *, size_t) = NULL;
static int (*v12n_ds_clnt_reg)(ds_capability_t *, ds_ops_t *);
static int (*v12n_ds_unreg_svc)(char *, boolean_t);

/*
 * Defines to support the 'agent-system' domain service.
 */

#define	LDMA_SYSTEM_NVERS		\
			(sizeof (v12n_ldma_system_vers) / sizeof (ds_ver_t))
static ds_ver_t v12n_ldma_system_vers[] = { { 1, 0} };

static ds_capability_t v12n_ldma_cap = {
	LDMA_NAME_SYSTEM,	/* svc_id */
	v12n_ldma_system_vers,	/* vers */
	LDMA_SYSTEM_NVERS	/* nvers */
};

static void v12n_ldma_register_handler(ds_hdl_t hdl, ds_cb_arg_t arg,
    ds_ver_t *ver, ds_domain_hdl_t dhdl);
static void v12n_ldma_data_handler(ds_hdl_t hdl, ds_cb_arg_t arg, void *buf,
    size_t buflen);

static ds_ops_t v12n_ldma_ops = {
	v12n_ldma_register_handler,	/* ds_reg_cb */
	NULL,				/* ds_unreg_cb */
	v12n_ldma_data_handler,		/* ds_data_cb */
	NULL				/* ds_cb_arg */
};

/* v12n_ldma_cv_state values */
#define	V12N_LDMA_CVINVALID	-1	/* invalid value for cv_state */
#define	V12N_LDMA_REGWAITING	0	/* waiting for ctrl domain reg */
#define	V12N_LDMA_REGRECEIVED	1	/* received ctrl domain reg */
#define	V12N_LDMA_MSGWAITING	2	/* waiting for message response */
#define	V12N_LDMA_MSGRECEIVED	3	/* received message response */
#define	V12N_LDMA_MSGERROR	4	/* received a bad message */

/* 'agent-system' data used in async registration/data message handlers */
static ds_hdl_t v12n_ldma_ctrl_hdl = DS_INVALID_HDL;
static int v12n_ldma_msgtype;
static char *v12n_ldma_msgstr;
static mutex_t v12n_ldma_lock = DEFAULTMUTEX;
static cond_t v12n_ldma_cv = DEFAULTCV;
static int v12n_ldma_cv_state = V12N_LDMA_CVINVALID;
static mutex_t v12n_ldma_cv_lock = DEFAULTMUTEX;

/* 'agent-system' timeout values in seconds */
static int v12n_ldma_timeout = 15;
static int v12n_ldma_sleeptime = 1;


#define	V12N_LDOMS_SUPPORTED	(V12N_CAP_SUPPORTED | V12N_CAP_ENABLED | \
				    V12N_CAP_IMPL_LDOMS)

#define	MD_DEVICE		"/dev/mdesc"

/*
 * libv12n routines to support /dev/mdesc.
 */

/*
 * Wrapper for MD free: need unused size argument.
 */
/* ARGSUSED */
static void
v12n_md_free(void *buf, size_t n)
{
	free(buf);
}

/*
 * Wrapper for MD init: read MD and invoke md_init_intern.
 */
static md_t *
v12n_md_init()
{
	md_t *mdp;
	char *buf = NULL;
	md_header_t mdh;
	int md_size;
	int fd;

	/*
	 * Open the Machine Description (MD)
	 */
	fd = open(MD_DEVICE, O_RDONLY);
	if (fd == -1) {
		return (NULL);
	}

	if (read(fd, &mdh, sizeof (md_header_t)) != sizeof (md_header_t))
		goto errdone;

	md_size = sizeof (md_header_t) + mdh.node_blk_sz + mdh.name_blk_sz +
	    mdh.data_blk_sz;

	if ((buf = malloc(md_size)) == NULL)
		goto errdone;

	(void) memcpy(buf, &mdh, sizeof (md_header_t));
	if (read(fd, buf + sizeof (md_header_t),
	    md_size - sizeof (md_header_t)) != md_size - sizeof (md_header_t)) {
		goto errdone;
	}

	mdp = md_init_intern((uint64_t *)((void *)buf), malloc, v12n_md_free);

	(void) close(fd);

	return (mdp);

errdone:
	(void) close(fd);
	free(buf);

	return (NULL);
}

/*
 * Wrapper for md_fini.  Allow NULL md ptr and free MD buffer.
 */
static void
v12n_md_fini(void *md)
{
	md_impl_t *mdp = (md_impl_t *)md;

	if (mdp) {
		free(mdp->caddr);
		(void) md_fini(md);
	}
}

/*
 * See if LDoms domaining is enabled, returns 1 if enabled.
 * Get the value of the 'domaining-enabled' property under the
 * 'platform' node.  Value of 1 => domaining is enabled.
 */
static int
v12n_domaining_enabled()
{
	mde_cookie_t *nodes, rootnode;
	int nnodes;
	uint64_t prop_val = 0;
	md_t *mdp;

	if ((mdp = v12n_md_init()) == NULL) {
		return (0);
	}

	nnodes = md_node_count(mdp);
	nodes = malloc(nnodes * sizeof (mde_cookie_t));
	if (nodes == NULL) {
		v12n_md_fini(mdp);
		return (0);
	}

	rootnode = md_root_node(mdp);

	nnodes = md_scan_dag(mdp, rootnode, md_find_name(mdp, "platform"),
	    md_find_name(mdp, "fwd"), nodes);

	if (nnodes >= 1) {
		(void) md_get_prop_val(mdp, nodes[0], "domaining-enabled",
		    &prop_val);
	}

	v12n_md_fini(mdp);
	free(nodes);
	return (prop_val == 1);
}

int
v12n_capabilities()
{
	struct utsname uinfo;
	struct stat st;
	int cap;

	/*
	 * Check if this is an LDoms system. When using LDoms each
	 * domain should have a /dev/mdesc device providing access to
	 * the Machine Description (MD) of the domain. If this device
	 * does not exist then this is not an LDoms system.
	 */
	if (uname(&uinfo) == -1 || strcmp(uinfo.machine, "sun4v")) {
		/*
		 * Not sun4v -> LDoms not supported
		 */
		cap = 0;
	} else if (stat(MD_DEVICE, &st) == 0) {
		/*
		 * sun4v + /dev/mdesc exists -> Check if LDoms enabled
		 * via the 'domaining-enabled' property.
		 */
		cap = (V12N_CAP_SUPPORTED | V12N_CAP_IMPL_LDOMS |
		    (v12n_domaining_enabled() ? V12N_CAP_ENABLED : 0));
	} else if (errno == ENOENT) {
		/*
		 * sun4v + /dev/mdesc does not exist -> LDoms supported
		 * but not enabled.
		 */
		cap = (V12N_CAP_SUPPORTED | V12N_CAP_IMPL_LDOMS);
	}

	return (cap);
}

/*
 * Routines to support v12n_domain_roles.
 */
static int
v12n_scan_md_nodes(md_t *mdp, char *node_name, char *node_str_prop,
    char **props)
{
	mde_cookie_t *nodes, rootnode;
	int nnodes, i, j;
	char *prop_str;

	nnodes = md_node_count(mdp);
	nodes = malloc(nnodes * sizeof (mde_cookie_t));
	if (nodes == NULL) {
		return (0);
	}

	rootnode = md_root_node(mdp);

	nnodes = md_scan_dag(mdp, rootnode, md_find_name(mdp, node_name),
	    md_find_name(mdp, "fwd"), nodes);

	if (node_str_prop == NULL)
		return (nnodes > 0);

	for (i = 0; i < nnodes; i++) {
		if (md_get_prop_str(mdp, nodes[i], node_str_prop, &prop_str))
			continue;
		for (j = 0; props[j] != NULL; j++) {
			if (strcmp(prop_str, props[j]) == 0) {
				free(nodes);
				return (1);
			}
		}
	}
	free(nodes);
	return (0);
}

/*
 * Check if MD has a hypervisor access point, returns 1 if true.
 * Check the MD for a 'virtual-device-port' node whose 'vldc-svc-name' is
 * 'hvctl'.
 */
static int
v12n_check_hv_access(md_t *mdp)
{
	static char *hvctl_str[] = {
		"hvctl",
		NULL
	};

	return (v12n_scan_md_nodes(mdp, "virtual-device-port", "vldc-svc-name",
	    hvctl_str));
}

/*
 * Check if MD has a virtual device service (vcc, vsw, vds), returns 1 if true.
 * Need to check all the MD 'virtual-device' nodes for a 'device-type' property
 * of 'vcc', 'vsw' or 'vds'.
 */
static int
v12n_check_virtual_service(md_t *mdp)
{
	static char *vdevs[] = {
		"vcc",
		"vsw",
		"vds",
		NULL
	};

	return (v12n_scan_md_nodes(mdp, "virtual-device", "device-type",
	    vdevs));
}

/*
 * Check if MD has an physical I/O device node, returns 1 if true.
 */
static int
v12n_check_io_service(md_t *mdp)
{
	return (v12n_scan_md_nodes(mdp, "iodevice", NULL, NULL));
}

/*
 * Check if a MD node is root PCI device, returns 1 if true.
 * Need to check all the MD 'iodevice' nodes for a 'device-type' property
 * of 'pciex'.
 */
static int
v12n_check_root(md_t *mdp)
{
	static char *pciex[] = {
		"pciex",
		NULL
	};

	return (v12n_scan_md_nodes(mdp, "iodevice", "device-type", pciex));
}

/*
 * Get the domain roles for the domain.
 */
int
v12n_domain_roles()
{
	md_t *mdp;
	int roles = 0;

	if (v12n_capabilities() != V12N_LDOMS_SUPPORTED) {
		errno = ENOTSUP;
		return (-1);
	}

	if ((mdp = v12n_md_init()) == NULL) {
		errno = EACCES;
		return (-1);
	}

	if (v12n_check_hv_access(mdp))
		roles |= V12N_ROLE_CONTROL;

	if (v12n_check_virtual_service(mdp))
		roles |= V12N_ROLE_SERVICE;

	if (v12n_check_io_service(mdp))
		roles |= V12N_ROLE_IO;

	if (v12n_check_root(mdp))
		roles |= V12N_ROLE_ROOT;

	v12n_md_fini(mdp);

	return (roles);
}

/*
 * Get domain name from MD's virtual domain service node, returns 1 on success.
 * The domain name is a string property 'vlds-domain-name' under the
 * 'virtual-device' device node whose name is 'virtual-domain-service'.
 */
static int
v12n_get_md_domain_name(md_t *mdp, char **vds_dnamep)
{
	mde_cookie_t *vdev_nodes, rootnode;
	int list_size, nvdevs, num_nodes, i, rv;
	char *vldc_name;

	num_nodes = md_node_count(mdp);
	list_size = num_nodes * sizeof (mde_cookie_t);
	vdev_nodes = malloc(list_size);
	if (vdev_nodes == NULL) {
		return (0);
	}

	rootnode = md_root_node(mdp);

	nvdevs = md_scan_dag(mdp, rootnode, md_find_name(mdp, "virtual-device"),
	    md_find_name(mdp, "fwd"), vdev_nodes);

	rv = 0;
	for (i = 0; i < nvdevs; i++) {
		if (md_get_prop_str(mdp, vdev_nodes[i], "name", &vldc_name))
			continue;
		if (strcmp(vldc_name, "virtual-domain-service") == 0) {
			rv = (md_get_prop_str(mdp, vdev_nodes[i],
			    "vlds-domain-name", vds_dnamep) == 0);
			break;
		}
	}
	free(vdev_nodes);
	return (rv);
}

/*
 * String copyout utility.
 */
static size_t
v12n_string_copyout(char *sout, char *sfrom, size_t count)
{
	size_t ret = strlen(sfrom) + 1;

	if (sout != NULL && count > 0) {
		count = MIN(ret, count);
		(void) memcpy(sout, sfrom, count);
	}
	return (ret);
}

/*
 * Get the domain name of this domain.
 */
size_t
v12n_domain_name(char *buf, size_t count)
{
	md_t *mdp = NULL;
	char *ldmname;
	int rv = -1;

	if (v12n_capabilities() != V12N_LDOMS_SUPPORTED) {
		errno = ENOTSUP;
	} else if ((mdp = v12n_md_init()) == NULL) {
		errno = EACCES;
	} else if (!v12n_get_md_domain_name(mdp, &ldmname)) {
		errno = ESRCH;
	} else {
		rv = v12n_string_copyout(buf, ldmname, count);
	}

	v12n_md_fini(mdp);
	return (rv);
}

/*
 * Get UUID string from MD, returns 1 on success.
 * The UUID is a string property 'uuid' under the 'platform' node of the MD.
 */
static int
v12n_get_md_uuid_str(md_t *mdp, char **uuid_strp)
{
	mde_cookie_t *plat_nodes, rootnode;
	int list_size, npnodes, num_nodes, rv;

	num_nodes = md_node_count(mdp);
	list_size = num_nodes * sizeof (mde_cookie_t);
	plat_nodes = malloc(list_size);
	if (plat_nodes == NULL) {
		return (0);
	}

	rootnode = md_root_node(mdp);

	npnodes = md_scan_dag(mdp, rootnode, md_find_name(mdp, "platform"),
	    md_find_name(mdp, "fwd"), plat_nodes);

	if (npnodes >= 1)
		rv = !md_get_prop_str(mdp, plat_nodes[0], "uuid", uuid_strp);
	else
		rv = 0;

	free(plat_nodes);
	return (rv);
}

/*
 * Get the domain UUID.
 */
int
v12n_domain_uuid(uuid_t uuid)
{
	md_t *mdp = NULL;
	char *uuid_str;
	int rv = -1;

	if (v12n_capabilities() != V12N_LDOMS_SUPPORTED) {
		errno = ENOTSUP;
	} else if ((mdp = v12n_md_init()) == NULL) {
		errno = EACCES;
	} else if (!v12n_get_md_uuid_str(mdp, &uuid_str)) {
		errno = ESRCH;
	} else {
		rv = uuid_parse(uuid_str, uuid);
	}

	v12n_md_fini(mdp);

	return (rv);
}

/*
 * Send 'agent-system' request message.
 */
static int
v12n_ldma_send_request()
{
	ldma_message_header_t ldmamsg;

	if (v12n_ds_send_msg == NULL || v12n_ldma_ctrl_hdl == DS_INVALID_HDL)
		return (ENOENT);

	ldmamsg.msg_num = 0;
	ldmamsg.msg_type = v12n_ldma_msgtype;
	ldmamsg.msg_info = 0;
	return (v12n_ds_send_msg(v12n_ldma_ctrl_hdl, (char *)&ldmamsg,
	    sizeof (ldmamsg)));
}

/*
 * 'agent-system' registration handler.
 * If we get a registration from the control domain (domain 0), then send
 * the requested message.  Otherwise, ignore the registration.
 */
/* ARGSUSED */
static void
v12n_ldma_register_handler(ds_hdl_t hdl, ds_cb_arg_t arg, ds_ver_t *ver,
    ds_domain_hdl_t dhdl)
{

	/* got registration from control domain */
	if (dhdl == 0) {
		(void) mutex_lock(&v12n_ldma_cv_lock);
		if (v12n_ldma_cv_state == V12N_LDMA_REGWAITING) {
			v12n_ldma_ctrl_hdl = hdl;
			v12n_ldma_cv_state = V12N_LDMA_REGRECEIVED;
			(void) cond_signal(&v12n_ldma_cv);
		}
		(void) mutex_unlock(&v12n_ldma_cv_lock);
	}
}

/*
 * 'agent-system' data handler.
 */
/* ARGSUSED */
static void
v12n_ldma_data_handler(ds_hdl_t hdl, ds_cb_arg_t arg, void *buf,
    size_t buflen)
{
	char *data;
	ldma_message_header_t *ldmp;
	int n;
	int cv_state = V12N_LDMA_MSGERROR;

	/*
	 * Ignore any message not from the control domain.
	 */
	if (v12n_ldma_ctrl_hdl != hdl)
		return;

	/*
	 * Ignore any unexpected message.
	 */
	if (buflen < LDMA_MESSAGE_HEADER_SIZE)
		return;

	/*
	 * Ignore message with unexpected msgnum.
	 */
	ldmp = (ldma_message_header_t *)buf;
	if (ldmp->msg_num != 0)
		return;

	switch (ldmp->msg_type) {

	case LDMA_MSG_RESULT:
		if (ldmp->msg_info == 0 ||
		    ldmp->msg_info > LDMA_MESSAGE_DLEN(buflen)) {
			cv_state = V12N_LDMA_MSGERROR;
			break;
		}
		data = LDMA_HDR2DATA(buf);

		/* ensure that data ends with a '\0' */
		data[ldmp->msg_info - 1] = '\0';
		switch (v12n_ldma_msgtype) {

		case LDMA_MSGSYS_GET_SYSINFO:
			/*
			 * Control domain nodename is second string in the
			 * message.  Make sure there is enough data in the msg
			 * to have a second string.
			 */
			n = strlen(data);
			if (LDMA_MESSAGE_DLEN(buflen) <= n + 3) {
				cv_state = V12N_LDMA_MSGERROR;
				break;
			}
			data += n + 1;
			if ((v12n_ldma_msgstr = strdup(data)) == NULL)
				cv_state = V12N_LDMA_MSGERROR;
			else
				cv_state = V12N_LDMA_MSGRECEIVED;
			break;

		case LDMA_MSGSYS_GET_CHASSISNO:
			if ((v12n_ldma_msgstr = strdup(data)) == NULL)
				cv_state = V12N_LDMA_MSGERROR;
			else
				cv_state = V12N_LDMA_MSGRECEIVED;
			break;

		default:
			/* v12n_ldma_msgtype must be valid */
			ASSERT(0);
		}
		break;

	case LDMA_MSG_ERROR:
		cv_state = V12N_LDMA_MSGERROR;
		break;

	default:
		/* unexpected message, ignored */
		return;
	}

	(void) mutex_lock(&v12n_ldma_cv_lock);
	v12n_ldma_cv_state = cv_state;
	(void) cond_signal(&v12n_ldma_cv);
	(void) mutex_unlock(&v12n_ldma_cv_lock);
}


/*
 * libds doesn't exist on non-sun4v, dynamically load it and get the
 * function pointers to the needed lib functions.
 */
static int
v12n_libds_init(void)
{
	if (v12n_ds_dlhdl != NULL) {
		if (v12n_ds_clnt_reg == NULL || v12n_ds_send_msg == NULL ||
		    v12n_ds_unreg_svc == NULL)
			return (ENOENT);
		return (0);
	}

	if ((v12n_ds_dlhdl = dlopen("libds.so.1",
	    RTLD_NOW | RTLD_GLOBAL)) == NULL)
		return (ENOENT);

	if ((v12n_ds_clnt_reg = (int (*)(ds_capability_t *, ds_ops_t *))
	    dlsym(v12n_ds_dlhdl, "ds_clnt_reg")) == NULL)
		return (ENOENT);

	if ((v12n_ds_send_msg = (int (*)(ds_hdl_t, void *, size_t))
	    dlsym(v12n_ds_dlhdl, "ds_send_msg")) == NULL)
		return (ENOENT);

	if ((v12n_ds_unreg_svc = (int (*)(char *, boolean_t))
	    dlsym(v12n_ds_dlhdl, "ds_unreg_svc")) == NULL)
		return (ENOENT);

	return (0);
}

/*
 * Initiate and wait for an ldmad 'agent-system' domain service.
 * Dynamically load libds, register the client 'agent-system' service
 * and wait for a specified amount of time for the 'agent-system'
 * service on the control domain to respond to the request.
 */
static int
v12n_get_ldma_system_msg(int msgtype, char **strp)
{
	int tout;
	int err = 0;
	timestruc_t timeout;

	/*
	 * Ensure that there's only one thread trying to do a
	 * 'agent-system' client registration/message at a time.
	 */
	(void) mutex_lock(&v12n_ldma_lock);
	if ((err = v12n_libds_init()) != 0) {
		(void) mutex_unlock(&v12n_ldma_lock);
		return (err);
	}

	v12n_ldma_msgtype = msgtype;
	v12n_ldma_msgstr = NULL;

	/* initialize v12n_ldma_cv_state variable before registering service */
	(void) mutex_lock(&v12n_ldma_cv_lock);
	v12n_ldma_cv_state = V12N_LDMA_REGWAITING;
	(void) mutex_unlock(&v12n_ldma_cv_lock);

	/*
	 * Other instances may be trying to load the "agent-system" service.
	 * If a collision happens (EBUSY error), wait and try again.
	 */
	for (tout = 0; tout < v12n_ldma_timeout; tout += v12n_ldma_sleeptime) {
		if ((err = v12n_ds_clnt_reg(&v12n_ldma_cap,
		    &v12n_ldma_ops)) == 0)
			break;
		if (err != EALREADY) {
			goto done;
		}
		(void) sleep(v12n_ldma_sleeptime);
	}

	if (tout >= v12n_ldma_timeout) {
		err = EBUSY;
		goto done;
	}

	/*
	 * Wait for control domain registration.
	 */
	timeout.tv_sec = v12n_ldma_timeout;
	timeout.tv_nsec = 0;

	(void) mutex_lock(&v12n_ldma_cv_lock);
	while (v12n_ldma_cv_state == V12N_LDMA_REGWAITING) {
		if ((err = cond_reltimedwait(&v12n_ldma_cv,
		    &v12n_ldma_cv_lock, &timeout)) != EINTR)
			break;
	}

	/*
	 * Check for timeout or an error.
	 */
	if (v12n_ldma_cv_state != V12N_LDMA_REGRECEIVED) {
		if (err == 0)
			err = EPROTO;
		(void) mutex_unlock(&v12n_ldma_cv_lock);
		goto done;
	}

	/*
	 * Received a registration request, send the request message.
	 */
	v12n_ldma_cv_state = V12N_LDMA_MSGWAITING;
	if ((err = v12n_ldma_send_request()) != 0) {
		(void) mutex_unlock(&v12n_ldma_cv_lock);
		goto done;
	}

	while (v12n_ldma_cv_state == V12N_LDMA_MSGWAITING) {
		if ((err = cond_reltimedwait(&v12n_ldma_cv,
		    &v12n_ldma_cv_lock, &timeout)) != EINTR)
			break;
	}

	if (v12n_ldma_cv_state != V12N_LDMA_MSGRECEIVED) {
		if (err == 0)
			err = EPROTO;
		(void) mutex_unlock(&v12n_ldma_cv_lock);
		goto done;
	}

	v12n_ldma_cv_state = V12N_LDMA_CVINVALID;
	(void) mutex_unlock(&v12n_ldma_cv_lock);

	/*
	 * If v12n_ldma_msgstr is set, a valid data response was seen.
	 */
	if (v12n_ldma_msgstr == NULL)
		err = ENODATA;
	else {
		if (*v12n_ldma_msgstr == '\0' ||
		    (*strp = strdup(v12n_ldma_msgstr)) == NULL)
			err = ENODATA;
		free(v12n_ldma_msgstr);
		v12n_ldma_msgstr = NULL;
	}

done:
	v12n_ds_unreg_svc(LDMA_NAME_SYSTEM, B_TRUE);
	v12n_ldma_msgtype = -1;
	v12n_ldma_ctrl_hdl = DS_INVALID_HDL;
	(void) mutex_unlock(&v12n_ldma_lock);

	return (err);
}

/*
 * Get the nodename of the control domain.  Returns the equivalent
 * of 'uname -n' on the control domain.
 *   This is obtained via the 'agent-system' domain service provided
 *   by ldmad.
 */
size_t
v12n_ctrl_domain(char *buf, size_t count)
{
	char *str;
	int err;
	size_t rv = (size_t)(-1);

	if (v12n_capabilities() != V12N_LDOMS_SUPPORTED) {
		errno = ENOTSUP;
	} else if ((err = v12n_get_ldma_system_msg(LDMA_MSGSYS_GET_SYSINFO,
	    &str)) != 0) {
		errno = err;
	} else {
		rv = v12n_string_copyout(buf, str, count);
	}
	return (rv);
}

/*
 * Get the Chassis serial number from the Control Domain.
 *   This is obtained via the 'agent-system' domain service provided
 *   by ldmad.
 */
size_t
v12n_chassis_serialno(char *buf, size_t count)
{
	char *str;
	int err;
	size_t rv = (size_t)(-1);

	if (v12n_capabilities() != V12N_LDOMS_SUPPORTED) {
		errno = ENOTSUP;
	} else if ((err = v12n_get_ldma_system_msg(LDMA_MSGSYS_GET_CHASSISNO,
	    &str)) != 0) {
		errno = err;
	} else {
		rv = v12n_string_copyout(buf, str, count);
	}
	return (rv);
}