/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2020 Joyent, Inc.
 */

/*
 * This file implements the following two routines for serializing and
 * deserializing digraphs to/from XML, respectively:
 *
 * topo_digraph_serialize()
 * topo_digraph_deserialize()
 *
 * Refer to the following file for the XML schema being used:
 * usr/src/lib/fm/topo/maps/common/digraph-topology.dtd.1
 */
#include <time.h>
#include <sys/utsname.h>
#include <libxml/parser.h>
#include <libtopo.h>

#include <topo_digraph.h>
#include <topo_digraph_xml.h>

#define	__STDC_FORMAT_MACROS
#include <inttypes.h>

extern int xmlattr_to_int(topo_mod_t *, xmlNodePtr, const char *, uint64_t *);
static int serialize_nvpair(topo_hdl_t *thp, FILE *, uint_t, const char *,
    nvpair_t *);

static void
tdg_xml_nvstring(FILE *fp, uint_t pad, const char *name, const char *value)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s' %s='%s' />\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE, TDG_XML_STRING,
	    TDG_XML_VALUE, value);
}

static void
tdg_xml_nvlist(FILE *fp, uint_t pad, const char *name)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s'>\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE, TDG_XML_NVLIST);
}

static void
tdg_xml_nvuint8(FILE *fp, uint_t pad, const char *name, const uint8_t value)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s' %s='%u' />\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE, TDG_XML_UINT8,
	    TDG_XML_VALUE, value);
}

static void
tdg_xml_nvint8(FILE *fp, uint_t pad, const char *name, const uint8_t value)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s' %s='%d' />\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE, TDG_XML_INT8,
	    TDG_XML_VALUE, value);
}

static void
tdg_xml_nvuint16(FILE *fp, uint_t pad, const char *name, const uint8_t value)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s' %s='%u' />\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE, TDG_XML_UINT16,
	    TDG_XML_VALUE, value);
}

static void
tdg_xml_nvint16(FILE *fp, uint_t pad, const char *name, const uint8_t value)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s' %s='%d' />\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE, TDG_XML_INT16,
	    TDG_XML_VALUE, value);
}

static void
tdg_xml_nvuint32(FILE *fp, uint_t pad, const char *name, const uint32_t value)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s' %s='%u' />\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE, TDG_XML_UINT32,
	    TDG_XML_VALUE, value);
}

static void
tdg_xml_nvint32(FILE *fp, uint_t pad, const char *name, const int32_t value)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s' %s='%d' />\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE, TDG_XML_UINT32,
	    TDG_XML_VALUE, value);
}

static void
tdg_xml_nvuint64(FILE *fp, uint_t pad, const char *name, const uint64_t value)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s' %s='0x%" PRIx64 "' />\n",
	    pad, "", TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE,
	    TDG_XML_UINT64, TDG_XML_VALUE, value);
}

static void
tdg_xml_nvint64(FILE *fp, uint_t pad, const char *name, const int64_t value)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s' %s='%" PRIi64 "' />\n", pad,
	    "", TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE,
	    TDG_XML_UINT64, TDG_XML_VALUE, value);
}

static void
tdg_xml_nvdbl(FILE *fp, uint_t pad, const char *name, const double value)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s' %s='%lf' />\n", pad, ""
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE, TDG_XML_UINT64,
	    TDG_XML_VALUE, value);
}

static void
tdg_xml_nvarray(FILE *fp, uint_t pad, const char *name, const char *type)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s'>\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE, type);
}

static void
tdg_xml_nvint32arr(FILE *fp, uint_t pad, const char *name, int32_t *val,
    uint_t nelems)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s'>\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE,
	    TDG_XML_INT32_ARR);

	for (uint_t i = 0; i < nelems; i++) {
		(void) fprintf(fp, "%*s<%s %s='%d' />\n", (pad + 2), "",
		    TDG_XML_NVPAIR, TDG_XML_VALUE, val[i]);
	}
	(void) fprintf(fp, "%*s</%s>\n", pad, "", TDG_XML_NVPAIR);
}

static void
tdg_xml_nvuint32arr(FILE *fp, uint_t pad, const char *name, uint32_t *val,
    uint_t nelems)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s'>\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE,
	    TDG_XML_UINT32_ARR);

	for (uint_t i = 0; i < nelems; i++) {
		(void) fprintf(fp, "%*s<%s %s='%d' />\n", (pad + 2), "",
		    TDG_XML_NVPAIR, TDG_XML_VALUE, val[i]);
	}
	(void) fprintf(fp, "%*s</%s>\n", pad, "", TDG_XML_NVPAIR);
}

static void
tdg_xml_nvint64arr(FILE *fp, uint_t pad, const char *name, int64_t *val,
    uint_t nelems)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s'>\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE,
	    TDG_XML_INT64_ARR);

	for (uint_t i = 0; i < nelems; i++) {
		(void) fprintf(fp, "%*s<%s %s='%" PRIi64 "' />\n", (pad + 2),
		    "", TDG_XML_NVPAIR, TDG_XML_VALUE, val[i]);
	}
	(void) fprintf(fp, "%*s</%s>\n", pad, "", TDG_XML_NVPAIR);
}

static void
tdg_xml_nvuint64arr(FILE *fp, uint_t pad, const char *name, uint64_t *val,
    uint_t nelems)
{
	(void) fprintf(fp, "%*s<%s %s='%s' %s='%s'>\n", pad, "",
	    TDG_XML_NVPAIR, TDG_XML_NAME, name, TDG_XML_TYPE,
	    TDG_XML_UINT64_ARR);

	for (uint_t i = 0; i < nelems; i++) {
		(void) fprintf(fp, "%*s<%s %s='0x%" PRIx64 "' />\n", (pad + 2),
		    "", TDG_XML_NVPAIR, TDG_XML_VALUE, val[i]);
	}
	(void) fprintf(fp, "%*s</%s>\n", pad, "", TDG_XML_NVPAIR);
}

static int
serialize_nvpair_nvlist(topo_hdl_t *thp, FILE *fp, uint_t pad,
    const char *name, nvlist_t *nvl)
{
	nvpair_t *elem = NULL;

	tdg_xml_nvlist(fp, pad, name);

	(void) fprintf(fp, "%*s<%s>\n", pad, "", TDG_XML_NVLIST);

	while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) {
		char *nvname = nvpair_name(elem);

		if (serialize_nvpair(thp, fp, (pad + 2), nvname, elem) != 0) {
			/* errno set */
			return (-1);
		}
	}

	(void) fprintf(fp, "%*s</%s>\n", pad, "", TDG_XML_NVLIST);
	(void) fprintf(fp, "%*s</%s> <!-- %s -->\n", pad, "", TDG_XML_NVPAIR,
	    name);

	return (0);
}

static int
serialize_nvpair(topo_hdl_t *thp, FILE *fp, uint_t pad, const char *pname,
    nvpair_t *nvp)
{
	data_type_t type = nvpair_type(nvp);

	switch (type) {
		case DATA_TYPE_INT8: {
			int8_t val;

			if (nvpair_value_int8(nvp, &val) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvint8(fp, pad, pname, val);
			break;
		}
		case DATA_TYPE_UINT8: {
			uint8_t val;

			if (nvpair_value_uint8(nvp, &val) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvuint8(fp, pad, pname, val);
			break;
		}
		case DATA_TYPE_INT16: {
			int16_t val;

			if (nvpair_value_int16(nvp, &val) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvint16(fp, pad, pname, val);
			break;
		}
		case DATA_TYPE_UINT16: {
			uint16_t val;

			if (nvpair_value_uint16(nvp, &val) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvuint16(fp, pad, pname, val);
			break;
		}
		case DATA_TYPE_INT32: {
			int32_t val;

			if (nvpair_value_int32(nvp, &val) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvint32(fp, pad, pname, val);
			break;
		}
		case DATA_TYPE_UINT32: {
			uint32_t val;

			if (nvpair_value_uint32(nvp, &val) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvuint32(fp, pad, pname, val);
			break;
		}
		case DATA_TYPE_INT64: {
			int64_t val;

			if (nvpair_value_int64(nvp, &val) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvint64(fp, pad, pname, val);
			break;
		}
		case DATA_TYPE_UINT64: {
			uint64_t val;

			if (nvpair_value_uint64(nvp, &val) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvuint64(fp, pad, pname, val);
			break;
		}
		case DATA_TYPE_DOUBLE: {
			double val;

			if (nvpair_value_double(nvp, &val) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvdbl(fp, pad, pname, val);
			break;
		}
		case DATA_TYPE_STRING: {
			char *val;

			if (nvpair_value_string(nvp, &val) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvstring(fp, pad, pname, val);
			break;
		}
		case DATA_TYPE_NVLIST: {
			nvlist_t *nvl;

			if (nvpair_value_nvlist(nvp, &nvl) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			if (serialize_nvpair_nvlist(thp, fp, pad + 2, pname,
			    nvl) != 0) {
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));
			}
			break;
		}
		case DATA_TYPE_INT32_ARRAY: {
			uint_t nelems;
			int32_t *val;

			if (nvpair_value_int32_array(nvp, &val, &nelems) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvint32arr(fp, pad + 2, pname, val, nelems);

			break;
		}
		case DATA_TYPE_UINT32_ARRAY: {
			uint_t nelems;
			uint32_t *val;

			if (nvpair_value_uint32_array(nvp, &val, &nelems) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvuint32arr(fp, pad + 2, pname,  val, nelems);

			break;
		}
		case DATA_TYPE_INT64_ARRAY: {
			uint_t nelems;
			int64_t *val;

			if (nvpair_value_int64_array(nvp, &val, &nelems) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvint64arr(fp, pad + 2, pname,  val, nelems);

			break;
		}
		case DATA_TYPE_UINT64_ARRAY: {
			uint_t nelems;
			uint64_t *val;

			if (nvpair_value_uint64_array(nvp, &val, &nelems) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvuint64arr(fp, pad + 2, pname,  val, nelems);

			break;
		}
		case DATA_TYPE_STRING_ARRAY: {
			uint_t nelems;
			char **val;

			if (nvpair_value_string_array(nvp, &val, &nelems) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvarray(fp, pad, pname, TDG_XML_STRING_ARR);
			for (uint_t i = 0; i < nelems; i++) {
				(void) fprintf(fp, "%*s<%s %s='%s' />\n",
				    (pad + 2), "", TDG_XML_NVPAIR,
				    TDG_XML_VALUE, val[i]);
			}
			(void) fprintf(fp, "%*s</%s>\n", (pad + 2), "",
			    TDG_XML_NVPAIR);

			break;
		}
		case DATA_TYPE_NVLIST_ARRAY: {
			uint_t nelems;
			nvlist_t **val;

			if (nvpair_value_nvlist_array(nvp, &val, &nelems) != 0)
				return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));

			tdg_xml_nvarray(fp, pad, pname, TDG_XML_NVLIST_ARR);
			for (uint_t i = 0; i < nelems; i++) {
				nvpair_t *elem = NULL;

				(void) fprintf(fp, "%*s<%s>\n", (pad + 2), "",
				    TDG_XML_NVLIST);

				while ((elem = nvlist_next_nvpair(val[i],
				    elem)) != NULL) {
					char *nvname = nvpair_name(elem);

					if (serialize_nvpair(thp, fp,
					    (pad + 4), nvname, elem) != 0) {
						/* errno set */
						return (-1);
					}
				}

				(void) fprintf(fp, "%*s</%s>\n", (pad + 2), "",
				    TDG_XML_NVLIST);
			}
			(void) fprintf(fp, "%*s</%s>\n", pad, "",
			    TDG_XML_NVPAIR);

			break;
		}
		default:
			topo_dprintf(thp, TOPO_DBG_XML, "Invalid nvpair data "
			    "type: %d\n", type);
			(void) topo_hdl_seterrno(thp, ETOPO_MOD_XENUM);
			return (-1);
	}
	return (0);
}

static int
serialize_edge(topo_hdl_t *thp, topo_edge_t *edge, boolean_t last_edge,
    void *arg)
{
	nvlist_t *fmri = NULL;
	char *fmristr;
	int err;
	tnode_t *tn;
	FILE *fp = (FILE *)arg;

	tn = topo_vertex_node(edge->tve_vertex);
	if (topo_node_resource(tn, &fmri, &err) != 0 ||
	    topo_fmri_nvl2str(thp, fmri, &fmristr, &err) != 0) {
		/* errno set */
		nvlist_free(fmri);
		return (TOPO_WALK_ERR);
	}
	nvlist_free(fmri);

	(void) fprintf(fp, "%*s<%s %s='%s' />\n", 4, "", TDG_XML_EDGE,
	    TDG_XML_FMRI, fmristr);
	topo_hdl_strfree(thp, fmristr);

	return (TOPO_WALK_NEXT);
}

/*
 * Some node property values aren't available unless we go through the libtopo
 * API's topo_prop_get_* routines. We do that here to make sure the nodes have
 * all of their properties populated, then we vector off to type-specific
 * XML serialization functions.
 */
static int
serialize_property(topo_hdl_t *thp, FILE *fp, uint_t pad, tnode_t *tn,
    topo_propval_t *pv, const char *pgname)
{
	topo_type_t type = pv->tp_type;
	const char *pname = pv->tp_name;
	int err;
	char *name = TDG_XML_PROP_VALUE;

	switch (type) {
		case TOPO_TYPE_INT32: {
			int32_t val;

			if (topo_prop_get_int32(tn, pgname, pname, &val,
			    &err) != 0)
				return (-1);

			tdg_xml_nvint32(fp, pad, name, val);
			break;
		}
		case TOPO_TYPE_UINT32: {
			uint32_t val;

			if (topo_prop_get_uint32(tn, pgname, pname, &val,
			    &err) != 0)
				return (-1);

			tdg_xml_nvuint32(fp, pad, name, val);
			break;
		}
		case TOPO_TYPE_INT64: {
			int64_t val;

			if (topo_prop_get_int64(tn, pgname, pname, &val,
			    &err) != 0)
				return (-1);

			tdg_xml_nvint64(fp, pad, name, val);
			break;
		}
		case TOPO_TYPE_UINT64: {
			uint64_t val;

			if (topo_prop_get_uint64(tn, pgname, pname, &val,
			    &err) != 0)
				return (-1);

			tdg_xml_nvuint64(fp, pad, name, val);
			break;
		}
		case TOPO_TYPE_STRING: {
			char *val;

			if (topo_prop_get_string(tn, pgname, pname, &val,
			    &err) != 0)
				return (-1);

			tdg_xml_nvstring(fp, pad, name, val);

			topo_hdl_strfree(thp, val);
			break;
		}
		case TOPO_TYPE_FMRI: {
			nvlist_t *nvl;

			if (topo_prop_get_fmri(tn, pgname, pname, &nvl,
			    &err) != 0)
				return (-1);

			if (serialize_nvpair_nvlist(thp, fp, pad + 2, name,
			    nvl) != 0) {
				nvlist_free(nvl);
				return (-1);
			}

			nvlist_free(nvl);
			break;
		}
		case TOPO_TYPE_INT32_ARRAY: {
			uint_t nelems;
			int32_t *val;

			if (topo_prop_get_int32_array(tn, pgname, pname, &val,
			    &nelems, &err) != 0)
				return (-1);

			tdg_xml_nvint32arr(fp, pad, pname, val, nelems);
			topo_hdl_free(thp, val, (sizeof (int32_t) * nelems));
			break;
		}
		case TOPO_TYPE_UINT32_ARRAY: {
			uint_t nelems;
			uint32_t *val;

			if (topo_prop_get_uint32_array(tn, pgname, pname, &val,
			    &nelems, &err) != 0)
				return (-1);

			tdg_xml_nvuint32arr(fp, pad, pname,  val, nelems);
			topo_hdl_free(thp, val, (sizeof (uint32_t) * nelems));
			break;
		}
		case TOPO_TYPE_INT64_ARRAY: {
			uint_t nelems;
			int64_t *val;

			if (topo_prop_get_int64_array(tn, pgname, pname, &val,
			    &nelems, &err) != 0)
				return (-1);

			tdg_xml_nvint64arr(fp, pad, pname,  val, nelems);
			topo_hdl_free(thp, val, (sizeof (int64_t) * nelems));
			break;
		}
		case TOPO_TYPE_UINT64_ARRAY: {
			uint_t nelems;
			uint64_t *val;

			if (topo_prop_get_uint64_array(tn, pgname, pname, &val,
			    &nelems, &err) != 0)
				return (-1);

			tdg_xml_nvuint64arr(fp, pad, pname,  val, nelems);
			topo_hdl_free(thp, val, (sizeof (uint64_t) * nelems));
			break;
		}
		default:
			topo_dprintf(thp, TOPO_DBG_XML, "Invalid nvpair data "
			    "type: %d\n", type);
			(void) topo_hdl_seterrno(thp, ETOPO_MOD_XENUM);
			return (-1);
	}
	return (0);
}

static int
serialize_pgroups(topo_hdl_t *thp, FILE *fp, tnode_t *tn)
{
	topo_pgroup_t *pg;
	uint_t npgs = 0;

	for (pg = topo_list_next(&tn->tn_pgroups); pg != NULL;
	    pg = topo_list_next(pg)) {

		npgs++;
	}

	tdg_xml_nvarray(fp, 2, TDG_XML_PGROUPS, TDG_XML_NVLIST_ARR);

	for (pg = topo_list_next(&tn->tn_pgroups); pg != NULL;
	    pg = topo_list_next(pg)) {

		topo_proplist_t *pvl;
		uint_t nprops = 0;

		(void) fprintf(fp, "%*s<%s>\n", 4, "", TDG_XML_NVLIST);
		tdg_xml_nvstring(fp, 6, TOPO_PROP_GROUP_NAME,
		    pg->tpg_info->tpi_name);

		for (pvl = topo_list_next(&pg->tpg_pvals); pvl != NULL;
		    pvl = topo_list_next(pvl))
			nprops++;

		tdg_xml_nvarray(fp, 6, TDG_XML_PVALS, TDG_XML_NVLIST_ARR);

		for (pvl = topo_list_next(&pg->tpg_pvals); pvl != NULL;
		    pvl = topo_list_next(pvl)) {

			topo_propval_t *pv = pvl->tp_pval;

			(void) fprintf(fp, "%*s<%s>\n", 8, "", TDG_XML_NVLIST);
			tdg_xml_nvstring(fp, 10, TDG_XML_PROP_NAME,
			    pv->tp_name);
			tdg_xml_nvuint32(fp, 10, TDG_XML_PROP_TYPE,
			    pv->tp_type);

			if (serialize_property(thp, fp, 10, tn, pv,
			    pg->tpg_info->tpi_name) != 0) {
				/* errno set */
				return (-1);
			}
			(void) fprintf(fp, "%*s</%s>\n", 8, "",
			    TDG_XML_NVLIST);
		}

		(void) fprintf(fp, "%*s</%s> <!-- %s -->\n", 6, "",
		    TDG_XML_NVPAIR, TDG_XML_PVALS);
		(void) fprintf(fp, "%*s</%s>\n", 4, "", TDG_XML_NVLIST);
	}
	(void) fprintf(fp, "%*s</%s> <!-- %s -->\n", 2, "", TDG_XML_NVPAIR,
	    TDG_XML_PGROUPS);

	return (0);
}

static int
serialize_vertex(topo_hdl_t *thp, topo_vertex_t *vtx, boolean_t last_vtx,
    void *arg)
{
	nvlist_t *fmri = NULL;
	char *fmristr;
	tnode_t *tn;
	int err;
	FILE *fp = (FILE *)arg;

	tn = topo_vertex_node(vtx);
	if (topo_node_resource(tn, &fmri, &err) != 0 ||
	    topo_fmri_nvl2str(thp, fmri, &fmristr, &err) != 0) {
		/* errno set */
		nvlist_free(fmri);
		return (TOPO_WALK_ERR);
	}
	nvlist_free(fmri);

	(void) fprintf(fp, "<%s %s='%s' %s='0x%" PRIx64 "' %s='%s'>\n",
	    TDG_XML_VERTEX, TDG_XML_NAME, topo_node_name(tn),
	    TDG_XML_INSTANCE, topo_node_instance(tn),
	    TDG_XML_FMRI, fmristr);

	topo_hdl_strfree(thp, fmristr);

	if (serialize_pgroups(thp, fp, tn) != 0) {
		/* errno set */
		return (TOPO_WALK_ERR);
	}

	if (vtx->tvt_noutgoing != 0) {
		(void) fprintf(fp, "  <%s>\n", TDG_XML_OUTEDGES);

		if (topo_edge_iter(thp, vtx, serialize_edge, fp) != 0) {
			topo_dprintf(thp, TOPO_DBG_XML, "failed to iterate "
			    "edges on %s=%" PRIx64 "\n", topo_node_name(tn),
			    topo_node_instance(tn));
			/* errno set */
			return (TOPO_WALK_ERR);
		}
		(void) fprintf(fp, "  </%s>\n", TDG_XML_OUTEDGES);
	}
	(void) fprintf(fp, "</%s>\n\n", TDG_XML_VERTEX);

	return (TOPO_WALK_NEXT);
}

/*
 * This function takes a topo_digraph_t and serializes it to XML.
 *
 * The schema is described in detail in:
 * usr/src/lib/fm/topo/maps/common/digraph-topology.dtd.1
 *
 * On success, this function writes the XML to the specified file and
 * returns 0.
 *
 * On failure, this function returns -1.
 */
int
topo_digraph_serialize(topo_hdl_t *thp, topo_digraph_t *tdg, FILE *fp)
{
	struct utsname uts = { 0 };
	time_t utc_time;
	char tstamp[64];
	int ret;

	if ((ret = uname(&uts)) < 0) {
		topo_dprintf(thp, TOPO_DBG_XML, "uname failed (ret = %d)\n",
		    ret);
		return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));
	}

	if (time(&utc_time) < 0) {
		topo_dprintf(thp, TOPO_DBG_XML, "uname failed (%s)\n",
		    strerror(errno));
		return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));
	}

	/*
	 * strftime returns 0 if the size of the result is larger than the
	 * buffer size passed in to it.  We've sized tstamp to be pretty
	 * large, so this really shouldn't happen.
	 */
	if (strftime(tstamp, sizeof (tstamp), "%Y-%m-%dT%H:%M:%SZ",
	    gmtime(&utc_time)) == 0) {
		topo_dprintf(thp, TOPO_DBG_XML, "strftime failed\n");
		return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));
	}

	(void) fprintf(fp, "<?xml version=\"1.0\"?>\n");
	(void) fprintf(fp, "<!DOCTYPE topology SYSTEM \"%s\">\n", TDG_DTD);
	(void) fprintf(fp, "<%s %s='%s' %s='%s' %s='%s' %s='%s' %s='%s'>\n",
	    TDG_XML_TOPO_DIGRAPH, TDG_XML_SCHEME, tdg->tdg_scheme,
	    TDG_XML_NODENAME, uts.nodename, TDG_XML_OSVERSION, uts.version,
	    TDG_XML_PRODUCT, thp->th_product, TDG_XML_TSTAMP, tstamp);
	(void) fprintf(fp, "<%s>\n", TDG_XML_VERTICES);

	if (topo_vertex_iter(thp, tdg, serialize_vertex, fp) != 0) {
		topo_dprintf(thp, TOPO_DBG_XML, "\nfailed to iterate "
		    "vertices\n");
		/* errno set */
		return (-1);
	}

	(void) fprintf(fp, "</%s>\n", TDG_XML_VERTICES);
	(void) fprintf(fp, "</%s>\n", TDG_XML_TOPO_DIGRAPH);

	if (ferror(fp) != 0) {
		topo_dprintf(thp, TOPO_DBG_XML, "An unknown error ocurrred "
		    "while writing out the serialize topology.");
		return (topo_hdl_seterrno(thp, ETOPO_UNKNOWN));
	}
	return (0);
}

static xmlNodePtr
get_child_by_name(xmlNodePtr xn, xmlChar *name)
{
	for (xmlNodePtr cn = xn->xmlChildrenNode; cn != NULL; cn = cn->next)
		if (xmlStrcmp(cn->name, name) == 0)
			return (cn);

	return (NULL);
}

static void
dump_xml_node(topo_hdl_t *thp, xmlNodePtr xn)
{
	topo_dprintf(thp, TOPO_DBG_XML, "node: %s", (char *)xn->name);
	for (xmlAttrPtr attr = xn->properties; attr != NULL; attr = attr->next)
		topo_dprintf(thp, TOPO_DBG_XML, "attribute: %s",
		    (char *)attr->name);

	for (xmlNodePtr cn = xn->xmlChildrenNode; cn != NULL; cn = cn->next)
		topo_dprintf(thp, TOPO_DBG_XML, "\tchild node: %s",
		    (char *)cn->name);
}

struct edge_cb_arg {
	const char	*from_fmri;
	const char	*to_fmri;
	topo_vertex_t	*from_vtx;
	topo_vertex_t	*to_vtx;
};

static int
edge_cb(topo_hdl_t *thp, topo_vertex_t *vtx, boolean_t last_vtx, void *arg)
{
	struct edge_cb_arg *cbarg = arg;
	tnode_t *tn;
	nvlist_t *fmri = NULL;
	char *fmristr = NULL;
	int err;

	tn = topo_vertex_node(vtx);
	if (topo_node_resource(tn, &fmri, &err) != 0 ||
	    topo_fmri_nvl2str(thp, fmri, &fmristr, &err) != 0) {
		topo_dprintf(thp, TOPO_DBG_XML, "failed to convert FMRI for "
		    "%s=%" PRIx64 " to a string\n", topo_node_name(tn),
		    topo_node_instance(tn));
		if (thp->th_debug & TOPO_DBG_XML)
			nvlist_print(stdout, fmri);
		nvlist_free(fmri);
		return (TOPO_WALK_ERR);
	}
	nvlist_free(fmri);

	if (strcmp(fmristr, cbarg->from_fmri) == 0)
		cbarg->from_vtx = vtx;
	else if (strcmp(fmristr, cbarg->to_fmri) == 0)
		cbarg->to_vtx = vtx;

	topo_hdl_strfree(thp, fmristr);
	if (cbarg->from_vtx != NULL && cbarg->to_vtx != NULL)
		return (TOPO_WALK_TERMINATE);
	else
		return (TOPO_WALK_NEXT);
}

static int
deserialize_edges(topo_hdl_t *thp, topo_mod_t *mod, topo_digraph_t *tdg,
    xmlChar *from_fmri, xmlNodePtr xn)
{
	for (xmlNodePtr cn = xn->xmlChildrenNode; cn != NULL;
	    cn = cn->next) {
		xmlChar *fmri;
		struct edge_cb_arg cbarg = { 0 };

		if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_EDGE) != 0)
			continue;

		if ((fmri = xmlGetProp(cn, (xmlChar *)TDG_XML_FMRI)) == NULL) {
			topo_dprintf(thp, TOPO_DBG_XML,
			    "error parsing %s element", (char *)cn->name);
			dump_xml_node(thp, cn);
			return (-1);
		}
		cbarg.from_fmri = (char *)from_fmri;
		cbarg.to_fmri = (char *)fmri;

		if (topo_vertex_iter(mod->tm_hdl, tdg, edge_cb, &cbarg) != 0) {
			xmlFree(fmri);
			return (-1);
		}
		xmlFree(fmri);

		if (cbarg.from_vtx == NULL || cbarg.to_vtx == NULL) {
			return (-1);
		}
		if (topo_edge_new(mod, cbarg.from_vtx, cbarg.to_vtx) != 0) {
			return (-1);
		}
	}

	return (0);
}

static int
add_edges(topo_hdl_t *thp, topo_mod_t *mod, topo_digraph_t *tdg,
    xmlNodePtr xn)
{
	int ret = -1;
	nvlist_t *props = NULL;
	xmlChar *name = NULL, *fmri = NULL;
	xmlNodePtr cn;
	uint64_t inst;

	if ((name = xmlGetProp(xn, (xmlChar *)TDG_XML_NAME)) == NULL ||
	    (fmri = xmlGetProp(xn, (xmlChar *)TDG_XML_FMRI)) == NULL ||
	    xmlattr_to_int(mod, xn, TDG_XML_INSTANCE, &inst) != 0) {
		goto fail;
	}

	if ((cn = get_child_by_name(xn, (xmlChar *)TDG_XML_OUTEDGES)) !=
	    NULL) {
		if (deserialize_edges(thp, mod, tdg, fmri, cn) != 0)
			goto fail;
	}
	ret = 0;

fail:
	if (ret != 0) {
		topo_dprintf(thp, TOPO_DBG_XML, "%s: error parsing %s element",
		    __func__, TDG_XML_VERTEX);
		dump_xml_node(thp, xn);
	}
	nvlist_free(props);
	if (name != NULL)
		xmlFree(name);
	if (fmri != NULL)
		xmlFree(fmri);

	return (ret);
}

static topo_pgroup_info_t pginfo = {
	NULL,
	TOPO_STABILITY_PRIVATE,
	TOPO_STABILITY_PRIVATE,
	1
};

static int
add_props(topo_hdl_t *thp, topo_vertex_t *vtx, nvlist_t *pgroups)
{
	tnode_t *tn;
	nvlist_t **pgs;
	uint_t npgs = 0;

	tn = topo_vertex_node(vtx);
	if (nvlist_lookup_nvlist_array(pgroups, TDG_XML_PGROUPS, &pgs,
	    &npgs) != 0) {
		goto fail;
	}

	for (uint_t i = 0; i < npgs; i++) {
		char *pgname;
		nvlist_t **props;
		uint_t nprops;
		int err;

		if (nvlist_lookup_string(pgs[i], TDG_XML_PGROUP_NAME,
		    &pgname) != 0 ||
		    nvlist_lookup_nvlist_array(pgs[i], TDG_XML_PVALS, &props,
		    &nprops) != 0) {
			goto fail;
		}
		pginfo.tpi_name = pgname;

		if (topo_pgroup_create(tn, &pginfo, &err) != 0) {
			topo_dprintf(thp, TOPO_DBG_XML, "failed to create "
			    "pgroup: %s", pgname);
			goto fail;
		}
		for (uint_t j = 0; j < nprops; j++) {
			if (topo_prop_setprop(tn, pgname, props[j],
			    TOPO_PROP_IMMUTABLE, props[j], &err) != 0) {
				topo_dprintf(thp, TOPO_DBG_XML, "failed to "
				    "set properties in pgroup: %s", pgname);
				goto fail;
			}
		}
	}
	return (0);
fail:
	topo_dprintf(thp, TOPO_DBG_XML, "%s: error decoding properties for "
	    "%s=%" PRIx64, __func__, topo_node_name(tn),
	    topo_node_instance(tn));
	if (thp->th_debug & TOPO_DBG_XML)
		nvlist_print(stdout, pgroups);

	return (-1);
}

static void
free_nvlist_array(topo_hdl_t *thp, nvlist_t **nvlarr, uint_t nelems)
{
	for (uint_t i = 0; i < nelems; i++) {
		if (nvlarr[i] != NULL)
			nvlist_free(nvlarr[i]);
	}
	topo_hdl_free(thp, nvlarr, nelems * sizeof (nvlist_t *));
}

static boolean_t
is_overflow(topo_hdl_t *thp, uint64_t val, uint_t nbits)
{
	if ((val >> nbits) != 0) {
		topo_dprintf(thp, TOPO_DBG_XML, "value exceeds %u bits", nbits);
		return (B_TRUE);
	}
	return (B_FALSE);
}

/*
 * Recursive function for parsing nvpair XML elements, which can contain
 * nested nvlist and nvpair elements.
 */
static int
deserialize_nvpair(topo_hdl_t *thp, topo_mod_t *mod, nvlist_t *nvl,
    xmlNodePtr xn)
{
	int ret = -1;
	xmlChar *name = NULL, *type = NULL, *sval = NULL;
	uint64_t val;

	if ((name = xmlGetProp(xn, (xmlChar *)TDG_XML_NAME)) == NULL ||
	    (type = xmlGetProp(xn, (xmlChar *)TDG_XML_TYPE)) == NULL) {
		goto fail;
	}

	if (xmlStrcmp(type, (xmlChar *)TDG_XML_NVLIST) == 0) {
		nvlist_t *cnvl = NULL;

		if (topo_hdl_nvalloc(thp, &cnvl, NV_UNIQUE_NAME) != 0) {
			goto fail;
		}

		for (xmlNodePtr cn = xn->xmlChildrenNode;
		    cn != NULL; cn = cn->next) {

			if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_NVLIST) != 0)
				continue;

			for (xmlNodePtr gcn = cn->xmlChildrenNode;
			    gcn != NULL; gcn = gcn->next) {

				if (xmlStrcmp(gcn->name,
				    (xmlChar *)TDG_XML_NVPAIR) != 0)
					continue;
				if (deserialize_nvpair(thp, mod, cnvl, gcn) !=
				    0) {
					nvlist_free(cnvl);
					goto fail;
				}
			}
			if (nvlist_add_nvlist(nvl, (char *)name, cnvl) != 0) {
				nvlist_free(cnvl);
				goto fail;
			}
			nvlist_free(cnvl);
			break;
		}
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_INT8) == 0) {
		if (xmlattr_to_int(mod, xn, TDG_XML_VALUE, &val) != 0 ||
		    is_overflow(thp, val, 8) ||
		    nvlist_add_int8(nvl, (char *)name, (int8_t)val) != 0) {
			goto fail;
		}
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_INT16) == 0) {
		if (xmlattr_to_int(mod, xn, TDG_XML_VALUE, &val) != 0 ||
		    is_overflow(thp, val, 16) ||
		    nvlist_add_int16(nvl, (char *)name, (int16_t)val) != 0) {
			goto fail;
		}
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_INT32) == 0) {
		if (xmlattr_to_int(mod, xn, TDG_XML_VALUE, &val) != 0 ||
		    is_overflow(thp, val, 32) ||
		    nvlist_add_int32(nvl, (char *)name, (int32_t)val) != 0) {
			goto fail;
		}
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_INT64) == 0) {
		if (xmlattr_to_int(mod, xn, TDG_XML_VALUE, &val) != 0 ||
		    nvlist_add_int64(nvl, (char *)name, (int64_t)val) != 0) {
			goto fail;
		}
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_UINT8) == 0) {
		if (xmlattr_to_int(mod, xn, TDG_XML_VALUE, &val) != 0 ||
		    is_overflow(thp, val, 8) ||
		    nvlist_add_uint8(nvl, (char *)name, (uint8_t)val) != 0) {
			goto fail;
		}
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_UINT16) == 0) {
		if (xmlattr_to_int(mod, xn, TDG_XML_VALUE, &val) != 0 ||
		    is_overflow(thp, val, 16) ||
		    nvlist_add_uint16(nvl, (char *)name, (uint16_t)val) != 0) {
			goto fail;
		}
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_UINT32) == 0) {
		if (xmlattr_to_int(mod, xn, TDG_XML_VALUE, &val) != 0 ||
		    is_overflow(thp, val, 32) ||
		    nvlist_add_uint32(nvl, (char *)name, (uint32_t)val) != 0) {
			goto fail;
		}
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_UINT64) == 0) {
		if (xmlattr_to_int(mod, xn, TDG_XML_VALUE, &val) != 0 ||
		    nvlist_add_uint64(nvl, (char *)name, (uint64_t)val) != 0) {
			goto fail;
		}
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_STRING) == 0) {
		if ((sval = xmlGetProp(xn, (xmlChar *)TDG_XML_VALUE)) == NULL ||
		    nvlist_add_string(nvl, (char *)name, (char *)sval) != 0) {
			goto fail;
		}
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_NVLIST_ARR) == 0) {
		uint64_t nelem = 0;
		nvlist_t **nvlarr = NULL;
		uint_t i = 0;
		xmlNodePtr cn = xn->xmlChildrenNode;

		/*
		 * Count the number of child nvlist elements
		 */
		while (cn != NULL) {
			if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_NVLIST) ==
			    0) {
				nelem++;
			}
			cn = cn->next;
		}

		if ((nvlarr = topo_hdl_zalloc(thp,
		    (nelem * sizeof (nvlist_t *)))) == NULL) {
			goto fail;
		}

		for (cn = xn->xmlChildrenNode; cn != NULL; cn = cn->next) {
			if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_NVLIST) !=
			    0)
				continue;

			if (topo_hdl_nvalloc(thp, &nvlarr[i],
			    NV_UNIQUE_NAME) != 0) {
				free_nvlist_array(thp, nvlarr, nelem);
				goto fail;
			}

			for (xmlNodePtr gcn = cn->xmlChildrenNode;
			    gcn != NULL; gcn = gcn->next) {
				if (xmlStrcmp(gcn->name,
				    (xmlChar *)TDG_XML_NVPAIR) != 0)
					continue;
				if (deserialize_nvpair(thp, mod, nvlarr[i],
				    gcn) != 0) {
					free_nvlist_array(thp, nvlarr, nelem);
					goto fail;
				}
			}
			i++;
		}
		if (nvlist_add_nvlist_array(nvl, (char *)name, nvlarr,
		    nelem) != 0) {
			free_nvlist_array(thp, nvlarr, nelem);
			goto fail;
		}
		free_nvlist_array(thp, nvlarr, nelem);
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_UINT32_ARR) == 0) {
		uint64_t nelem = 0;
		uint32_t *arr = NULL;
		uint_t i = 0;
		xmlNodePtr cn = xn->xmlChildrenNode;

		/*
		 * Count the number of child nvpair elements
		 */
		while (cn != NULL) {
			if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_NVPAIR) ==
			    0) {
				nelem++;
			}
			cn = cn->next;
		}

		if ((arr = topo_hdl_zalloc(thp,
		    (nelem * sizeof (uint32_t)))) == NULL) {
			goto fail;
		}

		for (cn = xn->xmlChildrenNode; cn != NULL; cn = cn->next) {
			if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_NVPAIR) != 0)
				continue;

			if (xmlattr_to_int(mod, cn, TDG_XML_VALUE, &val) != 0) {
				topo_hdl_free(thp, arr,
				    (nelem * sizeof (uint32_t)));
				goto fail;
			}

			arr[i] = val;
			i++;
		}
		if (nvlist_add_uint32_array(nvl, (char *)name, arr,
		    nelem) != 0) {
			topo_hdl_free(thp, arr, (nelem * sizeof (uint32_t)));
			goto fail;
		}
		topo_hdl_free(thp, arr, (nelem * sizeof (uint32_t)));
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_INT32_ARR) == 0) {
		uint64_t nelem = 0;
		int32_t *arr = NULL;
		uint_t i = 0;
		xmlNodePtr cn = xn->xmlChildrenNode;

		/*
		 * Count the number of child nvpair elements
		 */
		while (cn != NULL) {
			if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_NVPAIR) ==
			    0) {
				nelem++;
			}
			cn = cn->next;
		}

		if ((arr = topo_hdl_zalloc(thp,
		    (nelem * sizeof (int32_t)))) == NULL) {
			goto fail;
		}

		for (cn = xn->xmlChildrenNode; cn != NULL; cn = cn->next) {
			if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_NVPAIR) != 0)
				continue;

			if (xmlattr_to_int(mod, cn, TDG_XML_VALUE, &val) != 0) {
				topo_hdl_free(thp, arr,
				    (nelem * sizeof (int32_t)));
				goto fail;
			}

			arr[i] = val;
			i++;
		}
		if (nvlist_add_int32_array(nvl, (char *)name, arr,
		    nelem) != 0) {
			topo_hdl_free(thp, arr, (nelem * sizeof (int32_t)));
			goto fail;
		}
		topo_hdl_free(thp, arr, (nelem * sizeof (int32_t)));
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_UINT64_ARR) == 0) {
		uint64_t nelem = 0, *arr = NULL;
		uint_t i = 0;
		xmlNodePtr cn = xn->xmlChildrenNode;

		/*
		 * Count the number of child nvpair elements
		 */
		while (cn != NULL) {
			if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_NVPAIR) ==
			    0) {
				nelem++;
			}
			cn = cn->next;
		}

		if ((arr = topo_hdl_zalloc(thp,
		    (nelem * sizeof (uint64_t)))) == NULL) {
			goto fail;
		}

		for (cn = xn->xmlChildrenNode; cn != NULL; cn = cn->next) {
			if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_NVPAIR) != 0)
				continue;

			if (xmlattr_to_int(mod, cn, TDG_XML_VALUE, &val) != 0) {
				topo_hdl_free(thp, arr,
				    (nelem * sizeof (uint64_t)));
				goto fail;
			}

			arr[i] = val;
			i++;
		}
		if (nvlist_add_uint64_array(nvl, (char *)name, arr,
		    nelem) != 0) {
			topo_hdl_free(thp, arr, (nelem * sizeof (uint64_t)));
			goto fail;
		}
		topo_hdl_free(thp, arr, (nelem * sizeof (uint64_t)));
	} else if (xmlStrcmp(type, (xmlChar *)TDG_XML_INT64_ARR) == 0) {
		uint64_t nelem = 0;
		int64_t *arr = NULL;
		uint_t i = 0;
		xmlNodePtr cn = xn->xmlChildrenNode;

		/*
		 * Count the number of child nvpair elements
		 */
		while (cn != NULL) {
			if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_NVPAIR) ==
			    0) {
				nelem++;
			}
			cn = cn->next;
		}

		if ((arr = topo_hdl_zalloc(thp,
		    (nelem * sizeof (int64_t)))) == NULL) {
			goto fail;
		}

		for (cn = xn->xmlChildrenNode; cn != NULL; cn = cn->next) {
			if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_NVPAIR) != 0)
				continue;

			if (xmlattr_to_int(mod, cn, TDG_XML_VALUE, &val) != 0) {
				topo_hdl_free(thp, arr,
				    (nelem * sizeof (int64_t)));
				goto fail;
			}

			arr[i] = val;
			i++;
		}
		if (nvlist_add_int64_array(nvl, (char *)name, arr,
		    nelem) != 0) {
			topo_hdl_free(thp, arr, (nelem * sizeof (int64_t)));
			goto fail;
		}
		topo_hdl_free(thp, arr, (nelem * sizeof (int64_t)));
	}
	ret = 0;
fail:
	if (ret != 0) {
		topo_dprintf(thp, TOPO_DBG_XML, "%s: error parsing %s "
		    "element: name: %s, type: %s, nvl: %p", __func__, xn->name,
		    (name != NULL) ? (char *)name : "MISSING!",
		    (type != NULL) ? (char *)type : "MISSING!", nvl);
		dump_xml_node(thp, xn);
	}
	if (name != NULL)
		xmlFree(name);
	if (type != NULL)
		xmlFree(type);
	if (sval != NULL)
		xmlFree(sval);

	return (ret);
}

static int
deserialize_vertex(topo_hdl_t *thp, topo_mod_t *mod, topo_digraph_t *tdg,
    xmlNodePtr xn)
{
	int ret = -1;
	topo_vertex_t *vtx = NULL;
	nvlist_t *props = NULL;
	xmlChar *name = NULL, *fmri = NULL;
	uint64_t inst;

	if ((name = xmlGetProp(xn, (xmlChar *)TDG_XML_NAME)) == NULL ||
	    (fmri = xmlGetProp(xn, (xmlChar *)TDG_XML_FMRI)) == NULL ||
	    xmlattr_to_int(mod, xn, TDG_XML_INSTANCE, &inst) != 0) {
		goto fail;
	}

	if ((vtx = topo_vertex_new(mod, (char *)name, inst)) == NULL) {
		goto fail;
	}

	for (xmlNodePtr cn = xn->xmlChildrenNode; cn != NULL; cn = cn->next) {
		if (xmlStrcmp(cn->name, (xmlChar *)TDG_XML_NVPAIR) == 0) {
			if (topo_hdl_nvalloc(thp, &props, NV_UNIQUE_NAME) != 0)
				goto fail;
			if (deserialize_nvpair(thp, mod, props, cn) != 0 ||
			    add_props(thp, vtx, props) != 0)
				goto fail;
		}
	}
	ret = 0;

fail:
	if (ret != 0) {
		topo_dprintf(thp, TOPO_DBG_XML, "%s: error parsing %s element",
		    __func__, TDG_XML_VERTEX);
		dump_xml_node(thp, xn);
	}
	nvlist_free(props);
	if (name != NULL)
		xmlFree(name);
	if (fmri != NULL)
		xmlFree(fmri);

	return (ret);
}

/*
 * This function takes a buffer containing XML data describing a directed graph
 * topology.  This data is parsed to the original directed graph is rehydrated.
 *
 * On success, a pointer to a topo_digraph_t representing the graph is
 * returned.  The caller is responsible for destroying the graph via a call to
 * topo_digraph_destroy()
 *
 * On failure, NULL is returned.
 */
topo_digraph_t *
topo_digraph_deserialize(topo_hdl_t *thp, const char *xml, size_t sz)
{
	xmlDocPtr doc;
	xmlDtdPtr dtd = NULL;
	xmlNodePtr root, vertices;
	xmlChar *scheme = NULL;
	topo_mod_t *mod;
	topo_digraph_t *tdg, *ret = NULL;

	if ((doc = xmlReadMemory(xml, sz, "", NULL, 0)) == NULL) {
		topo_dprintf(thp, TOPO_DBG_XML, "Failed to parse XML");
		goto fail;
	}

	/*
	 * As a sanity check, extract the DTD from the XML and verify it
	 * matches the DTD for a digraph topology.
	 */
	if ((dtd = xmlGetIntSubset(doc)) == NULL) {
		topo_dprintf(thp, TOPO_DBG_XML,  "document has no DTD.\n");
		goto fail;
	}

	if (strcmp((const char *)dtd->SystemID, TDG_DTD) != 0) {
		topo_dprintf(thp, TOPO_DBG_XML, "unexpected DTD: %s",
		    dtd->SystemID);
		goto fail;
	}

	/*
	 * Verify the root element is what we're expecting and then grab the
	 * FMRI scheme from its attributes.
	 */
	if ((root = xmlDocGetRootElement(doc)) == NULL) {
		topo_dprintf(thp, TOPO_DBG_XML, "document is empty.\n");
		goto fail;
	}

	if (xmlStrcmp(root->name, (xmlChar *)TDG_XML_TOPO_DIGRAPH) != 0 ||
	    (scheme = xmlGetProp(root, (xmlChar *)TDG_XML_SCHEME)) ==
	    NULL) {
		topo_dprintf(thp, TOPO_DBG_XML,
		    "failed to parse %s element", TDG_XML_TOPO_DIGRAPH);
		goto fail;
	}

	/*
	 * Load the topo module associated with this FMRI scheme.
	 */
	if ((mod = topo_mod_lookup(thp, (const char *)scheme, 1)) == NULL) {
		topo_dprintf(thp, TOPO_DBG_XML, "failed to load %s module",
		    scheme);
		goto fail;
	}
	/*
	 * If we have a builtin module for this scheme, then there will
	 * already be an empty digraph attached to the handle.  Otherwise,
	 * create a new empty digraph and attach it to the handle.
	 */
	tdg = topo_digraph_get(mod->tm_hdl, mod->tm_info->tmi_scheme);
	if (tdg == NULL) {
		if ((tdg = topo_digraph_new(thp, mod, (const char *)scheme)) ==
		    NULL) {
			topo_dprintf(thp, TOPO_DBG_XML, "failed to create new "
			    "digraph");
			goto fail;
		} else {
			topo_list_append(&thp->th_digraphs, tdg);
		}
	}

	/*
	 * Iterate through the vertex XML elements to reconstruct the graph
	 */
	vertices = get_child_by_name(root, (xmlChar *)TDG_XML_VERTICES);
	if (vertices == NULL ||
	    xmlStrcmp(vertices->name, (xmlChar *)TDG_XML_VERTICES) != 0) {
		topo_dprintf(thp, TOPO_DBG_XML, "failed to parse %s element",
		    TDG_XML_VERTICES);
		dump_xml_node(thp, root);
		goto fail;
	}

	for (xmlNodePtr xn = vertices->xmlChildrenNode; xn != NULL;
	    xn = xn->next) {
		if (xmlStrcmp(xn->name, (xmlChar *)TDG_XML_VERTEX) != 0)
			continue;
		if (deserialize_vertex(thp, mod, tdg, xn) != 0)
			goto fail;
	}

	/*
	 * Now that all of the vertices have been created, go back through
	 * the vertex XML elements and add the edges.
	 */
	for (xmlNodePtr xn = vertices->xmlChildrenNode; xn != NULL;
	    xn = xn->next) {
		if (xmlStrcmp(xn->name, (xmlChar *)TDG_XML_VERTEX) != 0)
			continue;
		if (add_edges(thp, mod, tdg, xn) != 0)
			goto fail;
	}

	ret = tdg;

fail:
	if (scheme != NULL)
		xmlFree(scheme);

	if (doc != NULL)
		xmlFreeDoc(doc);

	(void) topo_hdl_seterrno(thp, ETOPO_MOD_XENUM);
	return (ret);
}