libv12n/sparc/libv12n.c

/*
 * 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-sytem' 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);
}