17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
580ab886dSwesolows  * Common Development and Distribution License (the "License").
680ab886dSwesolows  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
2180ab886dSwesolows 
227c478bd9Sstevel@tonic-gate /*
237aec1d6eScindi  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate  */
267c478bd9Sstevel@tonic-gate 
277c478bd9Sstevel@tonic-gate /*
287c478bd9Sstevel@tonic-gate  * After having been declared, events, FMRIs and authorities must be defined
297c478bd9Sstevel@tonic-gate  * (instantiated) before they can be used as the subjects of commands.
307c478bd9Sstevel@tonic-gate  */
317c478bd9Sstevel@tonic-gate 
327c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
337c478bd9Sstevel@tonic-gate #include <libnvpair.h>
347c478bd9Sstevel@tonic-gate #include <string.h>
357c478bd9Sstevel@tonic-gate #include <assert.h>
367c478bd9Sstevel@tonic-gate 
377c478bd9Sstevel@tonic-gate #include <inj_event.h>
387c478bd9Sstevel@tonic-gate #include <inj_err.h>
397c478bd9Sstevel@tonic-gate #include <inj_lex.h>
407c478bd9Sstevel@tonic-gate #include <inj_string.h>
417c478bd9Sstevel@tonic-gate #include <inj.h>
427c478bd9Sstevel@tonic-gate 
437c478bd9Sstevel@tonic-gate static inj_hash_t inj_defns[3];
447c478bd9Sstevel@tonic-gate static int inj_defns_initialized;
457c478bd9Sstevel@tonic-gate 
467c478bd9Sstevel@tonic-gate /* Intrinsics (signed and unsigned integer integer constants) */
477c478bd9Sstevel@tonic-gate typedef struct intr {
487c478bd9Sstevel@tonic-gate 	uchar_t ei_signed;
497c478bd9Sstevel@tonic-gate 	uchar_t ei_width;
507c478bd9Sstevel@tonic-gate } intr_t;
517c478bd9Sstevel@tonic-gate 
527c478bd9Sstevel@tonic-gate static inj_hash_t *
item2hash(inj_itemtype_t item)537c478bd9Sstevel@tonic-gate item2hash(inj_itemtype_t item)
547c478bd9Sstevel@tonic-gate {
557c478bd9Sstevel@tonic-gate 	int i;
567c478bd9Sstevel@tonic-gate 
577c478bd9Sstevel@tonic-gate 	assert(item >= 0 && item < sizeof (inj_defns) / sizeof (inj_hash_t));
587c478bd9Sstevel@tonic-gate 
597c478bd9Sstevel@tonic-gate 	if (!inj_defns_initialized) {
607c478bd9Sstevel@tonic-gate 		for (i = 0; i < sizeof (inj_defns) / sizeof (inj_hash_t); i++)
617c478bd9Sstevel@tonic-gate 			inj_strhash_create(&inj_defns[i]);
627c478bd9Sstevel@tonic-gate 		inj_defns_initialized = 1;
637c478bd9Sstevel@tonic-gate 	}
647c478bd9Sstevel@tonic-gate 
657c478bd9Sstevel@tonic-gate 	return (&inj_defns[item]);
667c478bd9Sstevel@tonic-gate }
677c478bd9Sstevel@tonic-gate 
687c478bd9Sstevel@tonic-gate inj_defn_t *
inj_defn_lookup(const char * name,inj_memtype_t type)697c478bd9Sstevel@tonic-gate inj_defn_lookup(const char *name, inj_memtype_t type)
707c478bd9Sstevel@tonic-gate {
717c478bd9Sstevel@tonic-gate 	inj_hash_t *hash = item2hash(inj_mem2item(type));
727c478bd9Sstevel@tonic-gate 	inj_var_t *v;
737c478bd9Sstevel@tonic-gate 
747c478bd9Sstevel@tonic-gate 	if ((v = inj_strhash_lookup(hash, name)) == NULL)
757c478bd9Sstevel@tonic-gate 		return (NULL);
767c478bd9Sstevel@tonic-gate 
777c478bd9Sstevel@tonic-gate 	return (inj_hash_get_cookie(v));
787c478bd9Sstevel@tonic-gate }
797c478bd9Sstevel@tonic-gate 
807c478bd9Sstevel@tonic-gate static void
inj_defn_destroy_memlist(inj_defnmem_t * m)817c478bd9Sstevel@tonic-gate inj_defn_destroy_memlist(inj_defnmem_t *m)
827c478bd9Sstevel@tonic-gate {
837c478bd9Sstevel@tonic-gate 	inj_defnmem_t *n;
847c478bd9Sstevel@tonic-gate 
857c478bd9Sstevel@tonic-gate 	for (/* */; m != NULL; m = n) {
867c478bd9Sstevel@tonic-gate 		n = inj_list_next(m);
877c478bd9Sstevel@tonic-gate 
887c478bd9Sstevel@tonic-gate 		switch (m->dfm_type) {
897c478bd9Sstevel@tonic-gate 		case DEFNMEM_ARRAY:
907aec1d6eScindi 		case DEFNMEM_LIST:
917c478bd9Sstevel@tonic-gate 			inj_defn_destroy_memlist(inj_list_next(&m->dfm_list));
927c478bd9Sstevel@tonic-gate 			break;
937c478bd9Sstevel@tonic-gate 		default:
947c478bd9Sstevel@tonic-gate 			inj_strfree(m->dfm_str);
957c478bd9Sstevel@tonic-gate 		}
967c478bd9Sstevel@tonic-gate 	}
977c478bd9Sstevel@tonic-gate }
987c478bd9Sstevel@tonic-gate 
997c478bd9Sstevel@tonic-gate void
inj_defn_destroy(inj_defn_t * defn)1007c478bd9Sstevel@tonic-gate inj_defn_destroy(inj_defn_t *defn)
1017c478bd9Sstevel@tonic-gate {
1027c478bd9Sstevel@tonic-gate 	if (defn->defn_name != NULL)
1037c478bd9Sstevel@tonic-gate 		inj_strfree(defn->defn_name);
1047c478bd9Sstevel@tonic-gate 
105*aab83bb8SJosef 'Jeff' Sipek 	nvlist_free(defn->defn_nvl);
1067c478bd9Sstevel@tonic-gate 
1077c478bd9Sstevel@tonic-gate 	inj_defn_destroy_memlist(inj_list_next(&defn->defn_members));
1087c478bd9Sstevel@tonic-gate }
1097c478bd9Sstevel@tonic-gate 
1107c478bd9Sstevel@tonic-gate static inj_defnmem_t *
inj_defn_mem_create_common(inj_defnmemtype_t type)1117c478bd9Sstevel@tonic-gate inj_defn_mem_create_common(inj_defnmemtype_t type)
1127c478bd9Sstevel@tonic-gate {
1137c478bd9Sstevel@tonic-gate 	inj_defnmem_t *dfm = inj_zalloc(sizeof (inj_defnmem_t));
1147c478bd9Sstevel@tonic-gate 
1157c478bd9Sstevel@tonic-gate 	dfm->dfm_type = type;
1167c478bd9Sstevel@tonic-gate 	dfm->dfm_lineno = yylineno;
1177c478bd9Sstevel@tonic-gate 
1187c478bd9Sstevel@tonic-gate 	return (dfm);
1197c478bd9Sstevel@tonic-gate }
1207c478bd9Sstevel@tonic-gate 
1217c478bd9Sstevel@tonic-gate inj_defnmem_t *
inj_defn_mem_create(const char * str,inj_defnmemtype_t type)1227c478bd9Sstevel@tonic-gate inj_defn_mem_create(const char *str, inj_defnmemtype_t type)
1237c478bd9Sstevel@tonic-gate {
1247c478bd9Sstevel@tonic-gate 	inj_defnmem_t *dfm = inj_defn_mem_create_common(type);
1257c478bd9Sstevel@tonic-gate 
1267c478bd9Sstevel@tonic-gate 	dfm->dfm_str = str;
1277c478bd9Sstevel@tonic-gate 
1287c478bd9Sstevel@tonic-gate 	return (dfm);
1297c478bd9Sstevel@tonic-gate }
1307c478bd9Sstevel@tonic-gate 
1317c478bd9Sstevel@tonic-gate inj_defnmem_t *
inj_defn_mem_create_list(inj_defn_t * list,inj_defnmemtype_t type)1327c478bd9Sstevel@tonic-gate inj_defn_mem_create_list(inj_defn_t *list, inj_defnmemtype_t type)
1337c478bd9Sstevel@tonic-gate {
1347c478bd9Sstevel@tonic-gate 	inj_defnmem_t *dfm = inj_defn_mem_create_common(type);
1357c478bd9Sstevel@tonic-gate 
1367c478bd9Sstevel@tonic-gate 	dfm->dfm_list = list->defn_members;
1377c478bd9Sstevel@tonic-gate 
1387c478bd9Sstevel@tonic-gate 	inj_free(list, sizeof (inj_defn_t));
1397c478bd9Sstevel@tonic-gate 
1407c478bd9Sstevel@tonic-gate 	return (dfm);
1417c478bd9Sstevel@tonic-gate }
1427c478bd9Sstevel@tonic-gate 
1437c478bd9Sstevel@tonic-gate inj_defn_t *
inj_defn_create(inj_defnmem_t * dfm)1447c478bd9Sstevel@tonic-gate inj_defn_create(inj_defnmem_t *dfm)
1457c478bd9Sstevel@tonic-gate {
1467c478bd9Sstevel@tonic-gate 	inj_defn_t *defn = inj_zalloc(sizeof (inj_defn_t));
1477c478bd9Sstevel@tonic-gate 
1487c478bd9Sstevel@tonic-gate 	defn->defn_lineno = yylineno;
1497c478bd9Sstevel@tonic-gate 
1507c478bd9Sstevel@tonic-gate 	inj_list_append(&defn->defn_members, dfm);
1517c478bd9Sstevel@tonic-gate 
1527c478bd9Sstevel@tonic-gate 	return (defn);
1537c478bd9Sstevel@tonic-gate }
1547c478bd9Sstevel@tonic-gate 
1557c478bd9Sstevel@tonic-gate void
inj_defn_addmem(inj_defn_t * defn,inj_defnmem_t * dfm)1567c478bd9Sstevel@tonic-gate inj_defn_addmem(inj_defn_t *defn, inj_defnmem_t *dfm)
1577c478bd9Sstevel@tonic-gate {
1587c478bd9Sstevel@tonic-gate 	inj_list_append(&defn->defn_members, dfm);
1597c478bd9Sstevel@tonic-gate }
1607c478bd9Sstevel@tonic-gate 
1617c478bd9Sstevel@tonic-gate /*
1627c478bd9Sstevel@tonic-gate  * Validate the dimensions of an array.  If the declared array size was zero,
1637c478bd9Sstevel@tonic-gate  * accept (and return) whatever the definition used.  If fewer cells were
1647c478bd9Sstevel@tonic-gate  * defined than were declared, return the declared size - the calling code will
1657c478bd9Sstevel@tonic-gate  * fill the remaining cells with zeros.  The definition of more than the
1667c478bd9Sstevel@tonic-gate  * declared number of cells triggers an error.  We print and error message in
1677c478bd9Sstevel@tonic-gate  * this case and return the declared number.  This will allow processing to
1687c478bd9Sstevel@tonic-gate  * continue.  The act of emitting the error will guarantee that we never
1697c478bd9Sstevel@tonic-gate  * pass from parsing to program execution.
1707c478bd9Sstevel@tonic-gate  */
1717c478bd9Sstevel@tonic-gate static size_t
array_dim_check(inj_declmem_t * dlm,inj_defnmem_t * dfm)1727c478bd9Sstevel@tonic-gate array_dim_check(inj_declmem_t *dlm, inj_defnmem_t *dfm)
1737c478bd9Sstevel@tonic-gate {
1747c478bd9Sstevel@tonic-gate 	inj_list_t *l;
1757c478bd9Sstevel@tonic-gate 	size_t dfnelems;
1767c478bd9Sstevel@tonic-gate 
1777c478bd9Sstevel@tonic-gate 	for (dfnelems = 0, l = inj_list_next(&dfm->dfm_list); l != NULL;
1787c478bd9Sstevel@tonic-gate 	    l = inj_list_next(l), dfnelems++);
1797c478bd9Sstevel@tonic-gate 
1807c478bd9Sstevel@tonic-gate 	if (dlm->dlm_arrdim != 0 && dlm->dlm_arrdim != dfnelems) {
1817c478bd9Sstevel@tonic-gate 		yyerror(" %d: defined array has %d elements, expected %d\n",
1827c478bd9Sstevel@tonic-gate 		    dfm->dfm_lineno, dfnelems, dlm->dlm_arrdim);
1837c478bd9Sstevel@tonic-gate 		dfnelems = dlm->dlm_arrdim;
1847c478bd9Sstevel@tonic-gate 	}
1857c478bd9Sstevel@tonic-gate 
1867c478bd9Sstevel@tonic-gate 	return (MAX(dfnelems, dlm->dlm_arrdim));
1877c478bd9Sstevel@tonic-gate }
1887c478bd9Sstevel@tonic-gate 
1897c478bd9Sstevel@tonic-gate /*
1907c478bd9Sstevel@tonic-gate  * The inj_defn_memcmp_* routines serve two purposes.  First, they compare a
1917c478bd9Sstevel@tonic-gate  * given defined member with the corresponding declared member, signalling an
1927c478bd9Sstevel@tonic-gate  * error if the two are incompatible.
1937c478bd9Sstevel@tonic-gate  *
1947c478bd9Sstevel@tonic-gate  * Assuming that validation succeeds, an entry is added to the passed nvlist
1957c478bd9Sstevel@tonic-gate  * for the defined member.
1967c478bd9Sstevel@tonic-gate  */
1977c478bd9Sstevel@tonic-gate 
1987c478bd9Sstevel@tonic-gate /* Used to ease signed and unsigned integer validation */
1997c478bd9Sstevel@tonic-gate static const intr_t inj_intrinsics[] = {
2007c478bd9Sstevel@tonic-gate 	{ 0, 0 }, /* MEMTYPE_UNKNOWN */
2017c478bd9Sstevel@tonic-gate 	{ 1, 8 }, { 1, 16 }, { 1, 32 }, { 1, 64 },
2027c478bd9Sstevel@tonic-gate 	{ 0, 8 }, { 0, 16 }, { 0, 32 }, { 0, 64 }
2037c478bd9Sstevel@tonic-gate };
2047c478bd9Sstevel@tonic-gate 
2057c478bd9Sstevel@tonic-gate static int
inj_defn_memcmp_signed(const intr_t * intr,inj_declmem_t * dlm,inj_defnmem_t * dfm,nvlist_t * nvl)2067c478bd9Sstevel@tonic-gate inj_defn_memcmp_signed(const intr_t *intr, inj_declmem_t *dlm,
2077c478bd9Sstevel@tonic-gate     inj_defnmem_t *dfm, nvlist_t *nvl)
2087c478bd9Sstevel@tonic-gate {
2097c478bd9Sstevel@tonic-gate 	longlong_t val;
2107c478bd9Sstevel@tonic-gate 
2117c478bd9Sstevel@tonic-gate 	if (dfm->dfm_type != DEFNMEM_IMM && dfm->dfm_type != DEFNMEM_IDENT)
2127c478bd9Sstevel@tonic-gate 		return (inj_set_errno(EINVAL));
2137c478bd9Sstevel@tonic-gate 
2147c478bd9Sstevel@tonic-gate 	if (inj_strtoll(dfm->dfm_str, intr->ei_width, &val) < 0)
2157c478bd9Sstevel@tonic-gate 		return (-1); /* errno is set for us */
2167c478bd9Sstevel@tonic-gate 
2177c478bd9Sstevel@tonic-gate 	switch (dlm->dlm_type) {
2187c478bd9Sstevel@tonic-gate 	case MEMTYPE_INT8:
2197c478bd9Sstevel@tonic-gate 		errno = nvlist_add_int8(nvl, (char *)dlm->dlm_name,
2207c478bd9Sstevel@tonic-gate 		    (int8_t)val);
2217c478bd9Sstevel@tonic-gate 		break;
2227c478bd9Sstevel@tonic-gate 	case MEMTYPE_INT16:
2237c478bd9Sstevel@tonic-gate 		errno = nvlist_add_int16(nvl, (char *)dlm->dlm_name,
2247c478bd9Sstevel@tonic-gate 		    (int16_t)val);
2257c478bd9Sstevel@tonic-gate 		break;
2267c478bd9Sstevel@tonic-gate 	case MEMTYPE_INT32:
2277c478bd9Sstevel@tonic-gate 		errno = nvlist_add_int32(nvl, (char *)dlm->dlm_name,
2287c478bd9Sstevel@tonic-gate 		    (int32_t)val);
2297c478bd9Sstevel@tonic-gate 		break;
2307c478bd9Sstevel@tonic-gate 	case MEMTYPE_INT64:
2317c478bd9Sstevel@tonic-gate 		errno = nvlist_add_int64(nvl, (char *)dlm->dlm_name,
2327c478bd9Sstevel@tonic-gate 		    (int64_t)val);
2337c478bd9Sstevel@tonic-gate 	}
2347c478bd9Sstevel@tonic-gate 
2357c478bd9Sstevel@tonic-gate 	if (errno != 0)
2367c478bd9Sstevel@tonic-gate 		die("failed to add member %s\n", dlm->dlm_name);
2377c478bd9Sstevel@tonic-gate 
2387c478bd9Sstevel@tonic-gate 	return (0);
2397c478bd9Sstevel@tonic-gate }
2407c478bd9Sstevel@tonic-gate 
2417c478bd9Sstevel@tonic-gate static int
inj_defn_memcmp_unsigned(const intr_t * intr,inj_declmem_t * dlm,inj_defnmem_t * dfm,nvlist_t * nvl)2427c478bd9Sstevel@tonic-gate inj_defn_memcmp_unsigned(const intr_t *intr, inj_declmem_t *dlm,
2437c478bd9Sstevel@tonic-gate     inj_defnmem_t *dfm, nvlist_t *nvl)
2447c478bd9Sstevel@tonic-gate {
2457c478bd9Sstevel@tonic-gate 	u_longlong_t val;
2467c478bd9Sstevel@tonic-gate 
2477c478bd9Sstevel@tonic-gate 	if (dfm->dfm_type != DEFNMEM_IMM && dfm->dfm_type != DEFNMEM_IDENT)
2487c478bd9Sstevel@tonic-gate 		return (inj_set_errno(EINVAL));
2497c478bd9Sstevel@tonic-gate 
2507c478bd9Sstevel@tonic-gate 	if (inj_strtoull(dfm->dfm_str, intr->ei_width, &val) < 0)
2517c478bd9Sstevel@tonic-gate 		return (-1); /* errno is set for us */
2527c478bd9Sstevel@tonic-gate 
2537c478bd9Sstevel@tonic-gate 	switch (dlm->dlm_type) {
2547c478bd9Sstevel@tonic-gate 	case MEMTYPE_UINT8:
2557c478bd9Sstevel@tonic-gate 		errno = nvlist_add_uint8(nvl, (char *)dlm->dlm_name,
2567c478bd9Sstevel@tonic-gate 		    (uint8_t)val);
2577c478bd9Sstevel@tonic-gate 		break;
2587c478bd9Sstevel@tonic-gate 	case MEMTYPE_UINT16:
2597c478bd9Sstevel@tonic-gate 		errno = nvlist_add_uint16(nvl, (char *)dlm->dlm_name,
2607c478bd9Sstevel@tonic-gate 		    (uint16_t)val);
2617c478bd9Sstevel@tonic-gate 		break;
2627c478bd9Sstevel@tonic-gate 	case MEMTYPE_UINT32:
2637c478bd9Sstevel@tonic-gate 		errno = nvlist_add_uint32(nvl, (char *)dlm->dlm_name,
2647c478bd9Sstevel@tonic-gate 		    (uint32_t)val);
2657c478bd9Sstevel@tonic-gate 		break;
2667c478bd9Sstevel@tonic-gate 	case MEMTYPE_UINT64:
2677c478bd9Sstevel@tonic-gate 		errno = nvlist_add_uint64(nvl, (char *)dlm->dlm_name,
2687c478bd9Sstevel@tonic-gate 		    (uint64_t)val);
2697c478bd9Sstevel@tonic-gate 	}
2707c478bd9Sstevel@tonic-gate 
2717c478bd9Sstevel@tonic-gate 	if (errno != 0)
2727c478bd9Sstevel@tonic-gate 		die("failed to add member %s\n", dlm->dlm_name);
2737c478bd9Sstevel@tonic-gate 
2747c478bd9Sstevel@tonic-gate 	return (0);
2757c478bd9Sstevel@tonic-gate }
2767c478bd9Sstevel@tonic-gate 
2777c478bd9Sstevel@tonic-gate /* Validate an array of (un)signed integers. */
2787c478bd9Sstevel@tonic-gate static int
inj_defn_memcmp_intr_array(const intr_t * cont,inj_declmem_t * dlm,inj_defnmem_t * dfm,nvlist_t * nvl)2797c478bd9Sstevel@tonic-gate inj_defn_memcmp_intr_array(const intr_t *cont, inj_declmem_t *dlm,
2807c478bd9Sstevel@tonic-gate     inj_defnmem_t *dfm, nvlist_t *nvl)
2817c478bd9Sstevel@tonic-gate {
2827c478bd9Sstevel@tonic-gate 	typedef int (*adder_t)();
2837c478bd9Sstevel@tonic-gate 	static const adder_t signed_adders[] = {
2847c478bd9Sstevel@tonic-gate 		NULL, nvlist_add_int8_array, nvlist_add_int16_array,
2857c478bd9Sstevel@tonic-gate 		NULL, nvlist_add_int32_array, NULL, NULL, NULL,
2867c478bd9Sstevel@tonic-gate 		nvlist_add_int64_array
2877c478bd9Sstevel@tonic-gate 	};
2887c478bd9Sstevel@tonic-gate 	static const adder_t unsigned_adders[] = {
2897c478bd9Sstevel@tonic-gate 		NULL,
2907c478bd9Sstevel@tonic-gate 		nvlist_add_uint8_array, nvlist_add_uint16_array,
2917c478bd9Sstevel@tonic-gate 		NULL, nvlist_add_uint32_array, NULL, NULL, NULL,
2927c478bd9Sstevel@tonic-gate 		nvlist_add_uint64_array
2937c478bd9Sstevel@tonic-gate 	};
2947c478bd9Sstevel@tonic-gate 
2957c478bd9Sstevel@tonic-gate 	union {
2967c478bd9Sstevel@tonic-gate 		char *a;
2977c478bd9Sstevel@tonic-gate 		int8_t *a8; uint8_t *au8;
2987c478bd9Sstevel@tonic-gate 		int16_t *a16; uint16_t *au16;
2997c478bd9Sstevel@tonic-gate 		int32_t *a32; uint32_t *au32;
3007c478bd9Sstevel@tonic-gate 		int64_t *a64; uint64_t *au64;
3017c478bd9Sstevel@tonic-gate 	} a;
3027c478bd9Sstevel@tonic-gate 
3037c478bd9Sstevel@tonic-gate 	int (*adder)(nvlist_t *, const char *, char *, uint_t);
3047c478bd9Sstevel@tonic-gate 	size_t nelems;
3057c478bd9Sstevel@tonic-gate 	inj_defnmem_t *elem;
3067c478bd9Sstevel@tonic-gate 	char *arrbase, *arr;
3077c478bd9Sstevel@tonic-gate 	size_t arrsz;
3087c478bd9Sstevel@tonic-gate 	int err = 0;
3097c478bd9Sstevel@tonic-gate 	int i;
3107c478bd9Sstevel@tonic-gate 
3117c478bd9Sstevel@tonic-gate 	if (dfm->dfm_type != DEFNMEM_ARRAY)
3127c478bd9Sstevel@tonic-gate 		return (inj_set_errno(EINVAL));
3137c478bd9Sstevel@tonic-gate 
3147c478bd9Sstevel@tonic-gate 	/*
3157c478bd9Sstevel@tonic-gate 	 * Each nvlist array adder wants an array of its own type as input,
3167c478bd9Sstevel@tonic-gate 	 * which is reasonable, but it complicates our general implementation.
3177c478bd9Sstevel@tonic-gate 	 * We fight back with casting magic.
3187c478bd9Sstevel@tonic-gate 	 */
3197c478bd9Sstevel@tonic-gate 
3207c478bd9Sstevel@tonic-gate 	nelems = array_dim_check(dlm, dfm);
3217c478bd9Sstevel@tonic-gate 	arrsz = (nelems + 1) * (cont->ei_width / NBBY);
3227c478bd9Sstevel@tonic-gate 	arrbase = inj_zalloc(arrsz);
3237c478bd9Sstevel@tonic-gate 	a.a = arr = (char *)P2ROUNDUP((uintptr_t)arrbase,
3247c478bd9Sstevel@tonic-gate 	    cont->ei_width / NBBY);
3257c478bd9Sstevel@tonic-gate 
3267c478bd9Sstevel@tonic-gate 	adder = (cont->ei_signed ? signed_adders :
3277c478bd9Sstevel@tonic-gate 	    unsigned_adders)[cont->ei_width / NBBY];
3287c478bd9Sstevel@tonic-gate 	assert(adder != NULL);
3297c478bd9Sstevel@tonic-gate 
3307c478bd9Sstevel@tonic-gate 	for (i = 1, elem = inj_list_next(&dfm->dfm_list); elem != NULL;
3317c478bd9Sstevel@tonic-gate 	    elem = inj_list_next(elem), i++) {
3327c478bd9Sstevel@tonic-gate 		if (elem->dfm_type != DEFNMEM_IMM &&
3337c478bd9Sstevel@tonic-gate 		    elem->dfm_type != DEFNMEM_IDENT) {
3347c478bd9Sstevel@tonic-gate 			yyerror(" %d: array cell %d is invalid\n",
3357c478bd9Sstevel@tonic-gate 			    dfm->dfm_lineno, i);
3367c478bd9Sstevel@tonic-gate 			err++;
3377c478bd9Sstevel@tonic-gate 			continue;
3387c478bd9Sstevel@tonic-gate 		}
3397c478bd9Sstevel@tonic-gate 
3407c478bd9Sstevel@tonic-gate 		if (cont->ei_signed) {
3417c478bd9Sstevel@tonic-gate 			longlong_t val;
3427c478bd9Sstevel@tonic-gate 
3437c478bd9Sstevel@tonic-gate 			if (inj_strtoll(elem->dfm_str, cont->ei_width,
3447c478bd9Sstevel@tonic-gate 			    &val) < 0) {
3457c478bd9Sstevel@tonic-gate 				yyerror(" %d: array cell %d %s\n",
3467c478bd9Sstevel@tonic-gate 				    dfm->dfm_lineno, i, (errno == ERANGE ?
3477c478bd9Sstevel@tonic-gate 				    "out of range for type" : "invalid"));
3487c478bd9Sstevel@tonic-gate 				err++;
3497c478bd9Sstevel@tonic-gate 				continue;
3507c478bd9Sstevel@tonic-gate 			}
3517c478bd9Sstevel@tonic-gate 
3527c478bd9Sstevel@tonic-gate 			switch (cont->ei_width) {
3537c478bd9Sstevel@tonic-gate 			case 8:
3547c478bd9Sstevel@tonic-gate 				*a.a8++ = (int8_t)val;
3557c478bd9Sstevel@tonic-gate 				break;
3567c478bd9Sstevel@tonic-gate 			case 16:
3577c478bd9Sstevel@tonic-gate 				*a.a16++ = (int16_t)val;
3587c478bd9Sstevel@tonic-gate 				break;
3597c478bd9Sstevel@tonic-gate 			case 32:
3607c478bd9Sstevel@tonic-gate 				*a.a32++ = (int32_t)val;
3617c478bd9Sstevel@tonic-gate 				break;
3627c478bd9Sstevel@tonic-gate 			default:
3637c478bd9Sstevel@tonic-gate 				*a.a64++ = (int64_t)val;
3647c478bd9Sstevel@tonic-gate 			}
3657c478bd9Sstevel@tonic-gate 
3667c478bd9Sstevel@tonic-gate 		} else {
3677c478bd9Sstevel@tonic-gate 			u_longlong_t val;
3687c478bd9Sstevel@tonic-gate 
3697c478bd9Sstevel@tonic-gate 			if (inj_strtoull(elem->dfm_str, cont->ei_width,
3707c478bd9Sstevel@tonic-gate 			    &val) < 0) {
3717c478bd9Sstevel@tonic-gate 				yyerror(" %d: array cell %d %s\n",
3727c478bd9Sstevel@tonic-gate 				    dfm->dfm_lineno, i, (errno == ERANGE ?
3737c478bd9Sstevel@tonic-gate 				    "out of range for type" : "invalid"));
3747c478bd9Sstevel@tonic-gate 				err++;
3757c478bd9Sstevel@tonic-gate 				continue;
3767c478bd9Sstevel@tonic-gate 			}
3777c478bd9Sstevel@tonic-gate 
3787c478bd9Sstevel@tonic-gate 			switch (cont->ei_width) {
3797c478bd9Sstevel@tonic-gate 			case 8:
3807c478bd9Sstevel@tonic-gate 				*a.au8++ = (uint8_t)val;
3817c478bd9Sstevel@tonic-gate 				break;
3827c478bd9Sstevel@tonic-gate 			case 16:
3837c478bd9Sstevel@tonic-gate 				*a.au16++ = (uint16_t)val;
3847c478bd9Sstevel@tonic-gate 				break;
3857c478bd9Sstevel@tonic-gate 			case 32:
3867c478bd9Sstevel@tonic-gate 				*a.au32++ = (uint32_t)val;
3877c478bd9Sstevel@tonic-gate 				break;
3887c478bd9Sstevel@tonic-gate 			default:
3897c478bd9Sstevel@tonic-gate 				*a.au64++ = (uint64_t)val;
3907c478bd9Sstevel@tonic-gate 			}
3917c478bd9Sstevel@tonic-gate 		}
3927c478bd9Sstevel@tonic-gate 	}
3937c478bd9Sstevel@tonic-gate 
3947c478bd9Sstevel@tonic-gate 	if (err == 0 && (errno = adder(nvl, dlm->dlm_name, arr, nelems)) != 0)
3957c478bd9Sstevel@tonic-gate 		die("failed to add array member %s", dlm->dlm_name);
3967c478bd9Sstevel@tonic-gate 
3977c478bd9Sstevel@tonic-gate 	inj_free(arrbase, arrsz);
3987c478bd9Sstevel@tonic-gate 
3997c478bd9Sstevel@tonic-gate 	if (err != 0)
4007c478bd9Sstevel@tonic-gate 		return (inj_set_errno(EINVAL));
4017c478bd9Sstevel@tonic-gate 
4027c478bd9Sstevel@tonic-gate 	return (0);
4037c478bd9Sstevel@tonic-gate }
4047c478bd9Sstevel@tonic-gate 
4057c478bd9Sstevel@tonic-gate static int
bool2val(const char * str,boolean_t * valp)4067c478bd9Sstevel@tonic-gate bool2val(const char *str, boolean_t *valp)
4077c478bd9Sstevel@tonic-gate {
4087c478bd9Sstevel@tonic-gate 	if (strcasecmp(str, "true") == 0)
4097c478bd9Sstevel@tonic-gate 		*valp = 1;
4107c478bd9Sstevel@tonic-gate 	else if (strcasecmp(str, "false") == 0)
4117c478bd9Sstevel@tonic-gate 		*valp = 0;
4127c478bd9Sstevel@tonic-gate 	else
4137c478bd9Sstevel@tonic-gate 		return (-1);
4147c478bd9Sstevel@tonic-gate 
4157c478bd9Sstevel@tonic-gate 	return (0);
4167c478bd9Sstevel@tonic-gate }
4177c478bd9Sstevel@tonic-gate 
4187c478bd9Sstevel@tonic-gate static int
inj_defn_memcmp_bool(inj_declmem_t * dlm,inj_defnmem_t * dfm,nvlist_t * nvl)4197c478bd9Sstevel@tonic-gate inj_defn_memcmp_bool(inj_declmem_t *dlm, inj_defnmem_t *dfm, nvlist_t *nvl)
4207c478bd9Sstevel@tonic-gate {
4217c478bd9Sstevel@tonic-gate 	boolean_t val;
4227c478bd9Sstevel@tonic-gate 
4237c478bd9Sstevel@tonic-gate 	if (dfm->dfm_type != DEFNMEM_IDENT)
4247c478bd9Sstevel@tonic-gate 		return (inj_set_errno(EINVAL));
4257c478bd9Sstevel@tonic-gate 
4267c478bd9Sstevel@tonic-gate 	if (bool2val(dfm->dfm_str, &val) < 0)
4277c478bd9Sstevel@tonic-gate 		return (inj_set_errno(EINVAL));
4287c478bd9Sstevel@tonic-gate 
4297c478bd9Sstevel@tonic-gate 	if ((errno = nvlist_add_boolean_value(nvl, (char *)dlm->dlm_name,
4307c478bd9Sstevel@tonic-gate 	    val)) != 0)
4317c478bd9Sstevel@tonic-gate 		die("failed to add boolean member %s", dlm->dlm_name);
4327c478bd9Sstevel@tonic-gate 
4337c478bd9Sstevel@tonic-gate 	return (0);
4347c478bd9Sstevel@tonic-gate }
4357c478bd9Sstevel@tonic-gate 
4367c478bd9Sstevel@tonic-gate static int
inj_defn_memcmp_bool_array(inj_declmem_t * dlm,inj_defnmem_t * dfm,nvlist_t * nvl)4377c478bd9Sstevel@tonic-gate inj_defn_memcmp_bool_array(inj_declmem_t *dlm, inj_defnmem_t *dfm,
4387c478bd9Sstevel@tonic-gate     nvlist_t *nvl)
4397c478bd9Sstevel@tonic-gate {
4407c478bd9Sstevel@tonic-gate 	inj_defnmem_t *elem;
4417c478bd9Sstevel@tonic-gate 	boolean_t *arr;
4427c478bd9Sstevel@tonic-gate 	size_t nelems, arrsz;
4437c478bd9Sstevel@tonic-gate 	int err = 0;
4447c478bd9Sstevel@tonic-gate 	int i;
4457c478bd9Sstevel@tonic-gate 
4467c478bd9Sstevel@tonic-gate 	if (dfm->dfm_type != DEFNMEM_ARRAY)
4477c478bd9Sstevel@tonic-gate 		return (inj_set_errno(EINVAL));
4487c478bd9Sstevel@tonic-gate 
4497c478bd9Sstevel@tonic-gate 	nelems = array_dim_check(dlm, dfm);
4507c478bd9Sstevel@tonic-gate 	arrsz = nelems * sizeof (boolean_t);
4517c478bd9Sstevel@tonic-gate 	arr = inj_zalloc(arrsz);
4527c478bd9Sstevel@tonic-gate 
4537c478bd9Sstevel@tonic-gate 	for (i = 0, elem = inj_list_next(&dfm->dfm_list); elem != NULL;
4547c478bd9Sstevel@tonic-gate 	    elem = inj_list_next(elem), i++) {
4557c478bd9Sstevel@tonic-gate 		if (elem->dfm_type != DEFNMEM_IDENT) {
4567c478bd9Sstevel@tonic-gate 			yyerror(" %d: array cell %d is invalid\n",
4577c478bd9Sstevel@tonic-gate 			    dfm->dfm_lineno, i + 1);
4587c478bd9Sstevel@tonic-gate 			err++;
4597c478bd9Sstevel@tonic-gate 			continue;
4607c478bd9Sstevel@tonic-gate 		}
4617c478bd9Sstevel@tonic-gate 
4627c478bd9Sstevel@tonic-gate 		if (bool2val(elem->dfm_str, &arr[i]) < 0)
4637c478bd9Sstevel@tonic-gate 			return (inj_set_errno(EINVAL));
4647c478bd9Sstevel@tonic-gate 	}
4657c478bd9Sstevel@tonic-gate 
4667c478bd9Sstevel@tonic-gate 	if (err == 0 && (errno = nvlist_add_boolean_array(nvl,
4677c478bd9Sstevel@tonic-gate 	    (char *)dlm->dlm_name, arr, nelems)) != 0)
4687c478bd9Sstevel@tonic-gate 		die("failed to add boolean array member %s", dlm->dlm_name);
4697c478bd9Sstevel@tonic-gate 
4707c478bd9Sstevel@tonic-gate 	inj_free(arr, arrsz);
4717c478bd9Sstevel@tonic-gate 
4727c478bd9Sstevel@tonic-gate 	return (0);
4737c478bd9Sstevel@tonic-gate }
4747c478bd9Sstevel@tonic-gate 
4757c478bd9Sstevel@tonic-gate /* Used for both strings and enums */
4767c478bd9Sstevel@tonic-gate static int
inj_defn_memcmp_strenum(inj_declmem_t * dlm,inj_defnmem_t * dfm,nvlist_t * nvl)4777c478bd9Sstevel@tonic-gate inj_defn_memcmp_strenum(inj_declmem_t *dlm, inj_defnmem_t *dfm, nvlist_t *nvl)
4787c478bd9Sstevel@tonic-gate {
4797c478bd9Sstevel@tonic-gate 	inj_defnmemtype_t defnmemtype = (dlm->dlm_type == MEMTYPE_ENUM ?
4807c478bd9Sstevel@tonic-gate 	    DEFNMEM_IDENT : DEFNMEM_QSTRING);
4817c478bd9Sstevel@tonic-gate 	const char *strenum = (dlm->dlm_type == MEMTYPE_ENUM ? "enum" :
4827c478bd9Sstevel@tonic-gate 	    "string");
4837c478bd9Sstevel@tonic-gate 
4847c478bd9Sstevel@tonic-gate 	if (dfm->dfm_type != defnmemtype)
4857c478bd9Sstevel@tonic-gate 		return (inj_set_errno(EINVAL));
4867c478bd9Sstevel@tonic-gate 
4877c478bd9Sstevel@tonic-gate 	if ((errno = nvlist_add_string(nvl, (char *)dlm->dlm_name,
4887c478bd9Sstevel@tonic-gate 	    (char *)dfm->dfm_str)) != 0)
4897c478bd9Sstevel@tonic-gate 		die("failed to add %s member %s", strenum, dlm->dlm_name);
4907c478bd9Sstevel@tonic-gate 
4917c478bd9Sstevel@tonic-gate 	return (0);
4927c478bd9Sstevel@tonic-gate }
4937c478bd9Sstevel@tonic-gate 
4947c478bd9Sstevel@tonic-gate static int
inj_defn_memcmp_strenum_array(inj_declmem_t * dlm,inj_defnmem_t * dfm,nvlist_t * nvl)4957c478bd9Sstevel@tonic-gate inj_defn_memcmp_strenum_array(inj_declmem_t *dlm, inj_defnmem_t *dfm,
4967c478bd9Sstevel@tonic-gate     nvlist_t *nvl)
4977c478bd9Sstevel@tonic-gate {
4987c478bd9Sstevel@tonic-gate 	inj_defnmemtype_t defnmemtype = (dlm->dlm_type == MEMTYPE_ENUM ?
4997c478bd9Sstevel@tonic-gate 	    DEFNMEM_IDENT : DEFNMEM_QSTRING);
5007c478bd9Sstevel@tonic-gate 	const char *strenum = (dlm->dlm_type == MEMTYPE_ENUM ? "enum" :
5017c478bd9Sstevel@tonic-gate 	    "string");
5027c478bd9Sstevel@tonic-gate 
5037c478bd9Sstevel@tonic-gate 	inj_defnmem_t *elem;
5047c478bd9Sstevel@tonic-gate 	size_t nelems, arrsz;
5057c478bd9Sstevel@tonic-gate 	const char **arr;
5067c478bd9Sstevel@tonic-gate 	int err = 0;
5077c478bd9Sstevel@tonic-gate 	int i;
5087c478bd9Sstevel@tonic-gate 
5097c478bd9Sstevel@tonic-gate 	if (dfm->dfm_type != DEFNMEM_ARRAY)
5107c478bd9Sstevel@tonic-gate 		return (inj_set_errno(EINVAL));
5117c478bd9Sstevel@tonic-gate 
5127c478bd9Sstevel@tonic-gate 	nelems = array_dim_check(dlm, dfm);
5137c478bd9Sstevel@tonic-gate 	arrsz = nelems * sizeof (char *);
5147c478bd9Sstevel@tonic-gate 	arr = inj_zalloc(arrsz);
5157c478bd9Sstevel@tonic-gate 
5167c478bd9Sstevel@tonic-gate 	for (i = 0, elem = inj_list_next(&dfm->dfm_list); elem != NULL;
5177c478bd9Sstevel@tonic-gate 	    elem = inj_list_next(elem), i++) {
5187c478bd9Sstevel@tonic-gate 		if (elem->dfm_type != defnmemtype) {
5197c478bd9Sstevel@tonic-gate 			yyerror(" %d: array cell %d is invalid\n",
5207c478bd9Sstevel@tonic-gate 			    dfm->dfm_lineno, i + 1);
5217c478bd9Sstevel@tonic-gate 			err++;
5227c478bd9Sstevel@tonic-gate 			continue;
5237c478bd9Sstevel@tonic-gate 		}
5247c478bd9Sstevel@tonic-gate 
5257c478bd9Sstevel@tonic-gate 		if (dlm->dlm_type == MEMTYPE_ENUM &&
5267c478bd9Sstevel@tonic-gate 		    inj_strhash_lookup(dlm->dlm_enumvals, elem->dfm_str) ==
5277c478bd9Sstevel@tonic-gate 		    NULL) {
5287c478bd9Sstevel@tonic-gate 			yyerror(" %d: invalid enum value %s\n",
5297c478bd9Sstevel@tonic-gate 			    dfm->dfm_lineno, elem->dfm_str);
5307c478bd9Sstevel@tonic-gate 			err++;
5317c478bd9Sstevel@tonic-gate 			continue;
5327c478bd9Sstevel@tonic-gate 		}
5337c478bd9Sstevel@tonic-gate 
5347c478bd9Sstevel@tonic-gate 		arr[i] = elem->dfm_str;
5357c478bd9Sstevel@tonic-gate 	}
5367c478bd9Sstevel@tonic-gate 
5377c478bd9Sstevel@tonic-gate 	if (err == 0 && (errno = nvlist_add_string_array(nvl,
5387c478bd9Sstevel@tonic-gate 	    dlm->dlm_name, (char **)arr, nelems)) != 0)
5397c478bd9Sstevel@tonic-gate 		die("failed to add %s array member %s", strenum, dlm->dlm_name);
5407c478bd9Sstevel@tonic-gate 
5417c478bd9Sstevel@tonic-gate 	inj_free(arr, arrsz);
5427c478bd9Sstevel@tonic-gate 	return (0);
5437c478bd9Sstevel@tonic-gate }
5447c478bd9Sstevel@tonic-gate 
5457c478bd9Sstevel@tonic-gate /*
5467aec1d6eScindi  * Validator for embedded lists (events, fmris, authorities, lists, etc.).
5477aec1d6eScindi  * There are two cases to deal with here.  The user could either have provided
5487aec1d6eScindi  * the name of a previously-defined list, in which case we just make a copy of
5497aec1d6eScindi  * said list for insertion into ours.  Alternatively, the user could simply
5507aec1d6eScindi  * define a new list here.  In that case, we recursively invoke the member
5517c478bd9Sstevel@tonic-gate  * comparator, but against the list type for the member being defined.
5527c478bd9Sstevel@tonic-gate  */
5537c478bd9Sstevel@tonic-gate static nvlist_t *inj_defn_validate_memlist(inj_declmem_t *, inj_defnmem_t *);
5547c478bd9Sstevel@tonic-gate 
5557c478bd9Sstevel@tonic-gate /* Embedded definition */
5567c478bd9Sstevel@tonic-gate static nvlist_t *
inj_defn_memcmp_sub_list(inj_declmem_t * dlm,inj_defnmem_t * dfm)5577c478bd9Sstevel@tonic-gate inj_defn_memcmp_sub_list(inj_declmem_t *dlm, inj_defnmem_t *dfm)
5587c478bd9Sstevel@tonic-gate {
5597c478bd9Sstevel@tonic-gate 	inj_declmem_t *subdlm = inj_list_next(&dlm->dlm_decl->decl_members);
5607c478bd9Sstevel@tonic-gate 	inj_defnmem_t *subdfm = inj_list_next(&dfm->dfm_list);
5617c478bd9Sstevel@tonic-gate 
5627c478bd9Sstevel@tonic-gate 	return (inj_defn_validate_memlist(subdlm, subdfm));
5637c478bd9Sstevel@tonic-gate }
5647c478bd9Sstevel@tonic-gate 
5657c478bd9Sstevel@tonic-gate /* Reference to previously-defined thing */
5667c478bd9Sstevel@tonic-gate static nvlist_t *
inj_defn_memcmp_sub_defined(inj_declmem_t * dlm,inj_defnmem_t * dfm)5677c478bd9Sstevel@tonic-gate inj_defn_memcmp_sub_defined(inj_declmem_t *dlm, inj_defnmem_t *dfm)
5687c478bd9Sstevel@tonic-gate {
5697c478bd9Sstevel@tonic-gate 	inj_defn_t *subdefn;
5707c478bd9Sstevel@tonic-gate 	nvlist_t *new;
5717c478bd9Sstevel@tonic-gate 
5727c478bd9Sstevel@tonic-gate 	if ((subdefn = inj_defn_lookup(dfm->dfm_str, dlm->dlm_type)) == NULL) {
5737c478bd9Sstevel@tonic-gate 		yyerror(" %d: reference to undefined %s %s\n", dfm->dfm_lineno,
5747c478bd9Sstevel@tonic-gate 		    inj_mem2str(dlm->dlm_type), dfm->dfm_str);
5757c478bd9Sstevel@tonic-gate 		(void) inj_set_errno(EINVAL);
5767c478bd9Sstevel@tonic-gate 		return (NULL);
5777c478bd9Sstevel@tonic-gate 	}
5787c478bd9Sstevel@tonic-gate 
5797c478bd9Sstevel@tonic-gate 	if (subdefn->defn_decl != dlm->dlm_decl) {
5807c478bd9Sstevel@tonic-gate 		yyerror(" %d: %s %s is not a(n) %s\n", dfm->dfm_lineno,
5817c478bd9Sstevel@tonic-gate 		    inj_mem2str(dlm->dlm_type), dfm->dfm_str,
5827c478bd9Sstevel@tonic-gate 		    subdefn->defn_decl->decl_name);
5837c478bd9Sstevel@tonic-gate 		(void) inj_set_errno(EINVAL);
5847c478bd9Sstevel@tonic-gate 		return (NULL);
5857c478bd9Sstevel@tonic-gate 	}
5867c478bd9Sstevel@tonic-gate 
5877c478bd9Sstevel@tonic-gate 	assert(subdefn->defn_nvl != NULL);
5887c478bd9Sstevel@tonic-gate 
5897c478bd9Sstevel@tonic-gate 	if ((errno = nvlist_dup(subdefn->defn_nvl, &new, 0)) != 0) {
5907c478bd9Sstevel@tonic-gate 		die("failed to duplicate %s list %s",
5917c478bd9Sstevel@tonic-gate 		    inj_item2str(subdefn->defn_decl->decl_type), dfm->dfm_str);
5927c478bd9Sstevel@tonic-gate 	}
5937c478bd9Sstevel@tonic-gate 
5947c478bd9Sstevel@tonic-gate 	return (new);
5957c478bd9Sstevel@tonic-gate }
5967c478bd9Sstevel@tonic-gate 
5977c478bd9Sstevel@tonic-gate static nvlist_t *
inj_defn_memcmp_sub_makenvl(inj_declmem_t * dlm,inj_defnmem_t * dfm)5987c478bd9Sstevel@tonic-gate inj_defn_memcmp_sub_makenvl(inj_declmem_t *dlm, inj_defnmem_t *dfm)
5997c478bd9Sstevel@tonic-gate {
6007c478bd9Sstevel@tonic-gate 	inj_defnmemtype_t dftype = dfm->dfm_type;
6017c478bd9Sstevel@tonic-gate 	inj_memtype_t dltype = dlm->dlm_type;
6027c478bd9Sstevel@tonic-gate 	nvlist_t *new = NULL;
6037c478bd9Sstevel@tonic-gate 
6047aec1d6eScindi 	if (dftype == DEFNMEM_LIST)
6057c478bd9Sstevel@tonic-gate 		new = inj_defn_memcmp_sub_list(dlm, dfm);
6067c478bd9Sstevel@tonic-gate 	else if (dftype == DEFNMEM_IDENT && (dltype == MEMTYPE_EVENT ||
6077c478bd9Sstevel@tonic-gate 	    dltype == MEMTYPE_FMRI || dltype == MEMTYPE_AUTH))
6087c478bd9Sstevel@tonic-gate 		new = inj_defn_memcmp_sub_defined(dlm, dfm);
6097c478bd9Sstevel@tonic-gate 	else
6107c478bd9Sstevel@tonic-gate 		(void) inj_set_errno(EINVAL);
6117c478bd9Sstevel@tonic-gate 
6127c478bd9Sstevel@tonic-gate 	return (new);
6137c478bd9Sstevel@tonic-gate }
6147c478bd9Sstevel@tonic-gate 
6157c478bd9Sstevel@tonic-gate /* A single sub-list */
6167c478bd9Sstevel@tonic-gate static int
inj_defn_memcmp_sub(inj_declmem_t * dlm,inj_defnmem_t * dfm,nvlist_t * nvl)6177c478bd9Sstevel@tonic-gate inj_defn_memcmp_sub(inj_declmem_t *dlm, inj_defnmem_t *dfm, nvlist_t *nvl)
6187c478bd9Sstevel@tonic-gate {
6197c478bd9Sstevel@tonic-gate 	nvlist_t *new;
6207c478bd9Sstevel@tonic-gate 
6217c478bd9Sstevel@tonic-gate 	if ((new = inj_defn_memcmp_sub_makenvl(dlm, dfm)) == NULL)
6227c478bd9Sstevel@tonic-gate 		return (-1); /* errno is set for us */
6237c478bd9Sstevel@tonic-gate 
6247c478bd9Sstevel@tonic-gate 	if ((errno = nvlist_add_nvlist(nvl, (char *)dlm->dlm_name,
6257c478bd9Sstevel@tonic-gate 	    new)) != 0)
6267c478bd9Sstevel@tonic-gate 		die("failed to add list member %s", dlm->dlm_name);
6277c478bd9Sstevel@tonic-gate 
6287c478bd9Sstevel@tonic-gate 	return (0);
6297c478bd9Sstevel@tonic-gate }
6307c478bd9Sstevel@tonic-gate 
6317c478bd9Sstevel@tonic-gate /* An array of sub-lists (for example, an array of events of a given type) */
6327c478bd9Sstevel@tonic-gate static int
inj_defn_memcmp_sub_array(inj_declmem_t * dlm,inj_defnmem_t * dfm,nvlist_t * nvl)6337c478bd9Sstevel@tonic-gate inj_defn_memcmp_sub_array(inj_declmem_t *dlm, inj_defnmem_t *dfm, nvlist_t *nvl)
6347c478bd9Sstevel@tonic-gate {
6357c478bd9Sstevel@tonic-gate 	size_t nelems, arrsz;
6367c478bd9Sstevel@tonic-gate 	inj_defnmem_t *elem;
6377c478bd9Sstevel@tonic-gate 	nvlist_t **arr;
6387c478bd9Sstevel@tonic-gate 	int err = 0;
6397c478bd9Sstevel@tonic-gate 	int i;
6407c478bd9Sstevel@tonic-gate 
6417c478bd9Sstevel@tonic-gate 	if (dfm->dfm_type != DEFNMEM_ARRAY)
6427c478bd9Sstevel@tonic-gate 		return (inj_set_errno(EINVAL));
6437c478bd9Sstevel@tonic-gate 
6447c478bd9Sstevel@tonic-gate 	nelems = array_dim_check(dlm, dfm);
6457c478bd9Sstevel@tonic-gate 	arrsz = nelems * sizeof (char *);
6467c478bd9Sstevel@tonic-gate 	arr = inj_zalloc(arrsz);
6477c478bd9Sstevel@tonic-gate 
6487c478bd9Sstevel@tonic-gate 	for (i = 0, elem = inj_list_next(&dfm->dfm_list); elem != NULL;
6497c478bd9Sstevel@tonic-gate 	    elem = inj_list_next(elem), i++) {
6507c478bd9Sstevel@tonic-gate 		if ((arr[i] = inj_defn_memcmp_sub_makenvl(dlm, elem)) == NULL) {
6517c478bd9Sstevel@tonic-gate 			yyerror(" %d: array cell %d is invalid\n",
6527c478bd9Sstevel@tonic-gate 			    elem->dfm_lineno, i + 1);
6537c478bd9Sstevel@tonic-gate 			err++;
6547c478bd9Sstevel@tonic-gate 			continue;
6557c478bd9Sstevel@tonic-gate 		}
6567c478bd9Sstevel@tonic-gate 	}
6577c478bd9Sstevel@tonic-gate 
6587c478bd9Sstevel@tonic-gate 	if (err == 0 && (errno = nvlist_add_nvlist_array(nvl,
6597c478bd9Sstevel@tonic-gate 	    (char *)dlm->dlm_name, arr, nelems)) != 0)
6607c478bd9Sstevel@tonic-gate 		die("failed to add nvlist list member %s", dlm->dlm_name);
6617c478bd9Sstevel@tonic-gate 
6627c478bd9Sstevel@tonic-gate 	inj_free(arr, arrsz);
6637c478bd9Sstevel@tonic-gate 
6647c478bd9Sstevel@tonic-gate 	return (0);
6657c478bd9Sstevel@tonic-gate }
6667c478bd9Sstevel@tonic-gate 
6677c478bd9Sstevel@tonic-gate /*
6687c478bd9Sstevel@tonic-gate  * The declaration-definition member comparator.  Designed to recursive
6697aec1d6eScindi  * invocation to allow for the validation of embedded/referenced lists.
6707c478bd9Sstevel@tonic-gate  */
6717c478bd9Sstevel@tonic-gate nvlist_t *
inj_defn_validate_memlist(inj_declmem_t * dlm,inj_defnmem_t * dfm)6727c478bd9Sstevel@tonic-gate inj_defn_validate_memlist(inj_declmem_t *dlm, inj_defnmem_t *dfm)
6737c478bd9Sstevel@tonic-gate {
6747c478bd9Sstevel@tonic-gate 	const intr_t *intr;
6757c478bd9Sstevel@tonic-gate 	nvlist_t *nvl;
6767c478bd9Sstevel@tonic-gate 	int rc, nmem, dlnmem, dfnmem;
6777c478bd9Sstevel@tonic-gate 	int err = 0;
6787c478bd9Sstevel@tonic-gate 
6797c478bd9Sstevel@tonic-gate 	if ((errno = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) != 0)
6807c478bd9Sstevel@tonic-gate 		die("failed to allocate nvl for event");
6817c478bd9Sstevel@tonic-gate 
6827c478bd9Sstevel@tonic-gate 	for (nmem = 1; dlm != NULL && dfm != NULL;
6837c478bd9Sstevel@tonic-gate 	    dlm = inj_list_next(dlm), dfm = inj_list_next(dfm), nmem++) {
6847c478bd9Sstevel@tonic-gate 
6857c478bd9Sstevel@tonic-gate 		switch (dlm->dlm_type) {
6867c478bd9Sstevel@tonic-gate 		case MEMTYPE_INT8:
6877c478bd9Sstevel@tonic-gate 		case MEMTYPE_INT16:
6887c478bd9Sstevel@tonic-gate 		case MEMTYPE_INT32:
6897c478bd9Sstevel@tonic-gate 		case MEMTYPE_INT64:
6907c478bd9Sstevel@tonic-gate 			intr = &inj_intrinsics[dlm->dlm_type];
6917c478bd9Sstevel@tonic-gate 
6927c478bd9Sstevel@tonic-gate 			if (dlm->dlm_flags & DECLMEM_F_ARRAY) {
6937c478bd9Sstevel@tonic-gate 				rc = inj_defn_memcmp_intr_array(intr, dlm, dfm,
6947c478bd9Sstevel@tonic-gate 				    nvl);
6957c478bd9Sstevel@tonic-gate 			} else {
6967c478bd9Sstevel@tonic-gate 				rc = inj_defn_memcmp_signed(intr, dlm, dfm,
6977c478bd9Sstevel@tonic-gate 				    nvl);
6987c478bd9Sstevel@tonic-gate 			}
6997c478bd9Sstevel@tonic-gate 			break;
7007c478bd9Sstevel@tonic-gate 
7017c478bd9Sstevel@tonic-gate 		case MEMTYPE_UINT8:
7027c478bd9Sstevel@tonic-gate 		case MEMTYPE_UINT16:
7037c478bd9Sstevel@tonic-gate 		case MEMTYPE_UINT32:
7047c478bd9Sstevel@tonic-gate 		case MEMTYPE_UINT64:
7057c478bd9Sstevel@tonic-gate 			intr = &inj_intrinsics[dlm->dlm_type];
7067c478bd9Sstevel@tonic-gate 
7077c478bd9Sstevel@tonic-gate 			if (dlm->dlm_flags & DECLMEM_F_ARRAY) {
7087c478bd9Sstevel@tonic-gate 				rc = inj_defn_memcmp_intr_array(intr, dlm, dfm,
7097c478bd9Sstevel@tonic-gate 				    nvl);
7107c478bd9Sstevel@tonic-gate 			} else {
7117c478bd9Sstevel@tonic-gate 				rc = inj_defn_memcmp_unsigned(intr, dlm, dfm,
7127c478bd9Sstevel@tonic-gate 				    nvl);
7137c478bd9Sstevel@tonic-gate 			}
7147c478bd9Sstevel@tonic-gate 			break;
7157c478bd9Sstevel@tonic-gate 
7167c478bd9Sstevel@tonic-gate 		case MEMTYPE_BOOL:
7177c478bd9Sstevel@tonic-gate 			if (dlm->dlm_flags & DECLMEM_F_ARRAY)
7187c478bd9Sstevel@tonic-gate 				rc = inj_defn_memcmp_bool_array(dlm, dfm, nvl);
7197c478bd9Sstevel@tonic-gate 			else
7207c478bd9Sstevel@tonic-gate 				rc = inj_defn_memcmp_bool(dlm, dfm, nvl);
7217c478bd9Sstevel@tonic-gate 			break;
7227c478bd9Sstevel@tonic-gate 
7237c478bd9Sstevel@tonic-gate 		case MEMTYPE_STRING:
7247c478bd9Sstevel@tonic-gate 			if (dlm->dlm_flags & DECLMEM_F_ARRAY) {
7257c478bd9Sstevel@tonic-gate 				rc = inj_defn_memcmp_strenum_array(dlm, dfm,
7267c478bd9Sstevel@tonic-gate 				    nvl);
7277c478bd9Sstevel@tonic-gate 			} else
7287c478bd9Sstevel@tonic-gate 				rc = inj_defn_memcmp_strenum(dlm, dfm, nvl);
7297c478bd9Sstevel@tonic-gate 			break;
7307c478bd9Sstevel@tonic-gate 
7317c478bd9Sstevel@tonic-gate 		case MEMTYPE_ENUM:
7327c478bd9Sstevel@tonic-gate 			if (dlm->dlm_flags & DECLMEM_F_ARRAY) {
7337c478bd9Sstevel@tonic-gate 				rc = inj_defn_memcmp_strenum_array(dlm, dfm,
7347c478bd9Sstevel@tonic-gate 				    nvl);
7357c478bd9Sstevel@tonic-gate 			} else
7367c478bd9Sstevel@tonic-gate 				rc = inj_defn_memcmp_strenum(dlm, dfm, nvl);
7377c478bd9Sstevel@tonic-gate 			break;
7387c478bd9Sstevel@tonic-gate 
7397c478bd9Sstevel@tonic-gate 		case MEMTYPE_EVENT:
7407c478bd9Sstevel@tonic-gate 		case MEMTYPE_FMRI:
7417c478bd9Sstevel@tonic-gate 		case MEMTYPE_AUTH:
7427aec1d6eScindi 		case MEMTYPE_LIST:
7437c478bd9Sstevel@tonic-gate 			if (dlm->dlm_flags & DECLMEM_F_ARRAY)
7447c478bd9Sstevel@tonic-gate 				rc = inj_defn_memcmp_sub_array(dlm, dfm, nvl);
7457c478bd9Sstevel@tonic-gate 			else
7467c478bd9Sstevel@tonic-gate 				rc = inj_defn_memcmp_sub(dlm, dfm, nvl);
7477c478bd9Sstevel@tonic-gate 			break;
7487c478bd9Sstevel@tonic-gate 
7497c478bd9Sstevel@tonic-gate 		default:
7507c478bd9Sstevel@tonic-gate 			die("unknown decl member type %d on member %s\n",
7517c478bd9Sstevel@tonic-gate 			    dlm->dlm_type, dlm->dlm_name);
7527c478bd9Sstevel@tonic-gate 		}
7537c478bd9Sstevel@tonic-gate 
7547c478bd9Sstevel@tonic-gate 		if (rc < 0) {
7557c478bd9Sstevel@tonic-gate 			yyerror(" %d: %s for member %s\n", dfm->dfm_lineno,
7567c478bd9Sstevel@tonic-gate 			    (errno == ERANGE ? "value out of range" :
7577c478bd9Sstevel@tonic-gate 			    "invalid value"), dlm->dlm_name);
7587c478bd9Sstevel@tonic-gate 			err++;
7597c478bd9Sstevel@tonic-gate 		}
7607c478bd9Sstevel@tonic-gate 	}
7617c478bd9Sstevel@tonic-gate 
7627c478bd9Sstevel@tonic-gate 	dlnmem = dfnmem = nmem;
7637c478bd9Sstevel@tonic-gate 
7647c478bd9Sstevel@tonic-gate 	while (dlm != NULL) {
7657c478bd9Sstevel@tonic-gate 		dlm = inj_list_next(dlm);
7667c478bd9Sstevel@tonic-gate 		dlnmem++;
7677c478bd9Sstevel@tonic-gate 	}
7687c478bd9Sstevel@tonic-gate 
7697c478bd9Sstevel@tonic-gate 	while (dfm != NULL) {
7707c478bd9Sstevel@tonic-gate 		dfm = inj_list_next(dfm);
7717c478bd9Sstevel@tonic-gate 		dfnmem++;
7727c478bd9Sstevel@tonic-gate 	}
7737c478bd9Sstevel@tonic-gate 
7747c478bd9Sstevel@tonic-gate 	if (dlnmem != dfnmem) {
7757c478bd9Sstevel@tonic-gate 		yyerror("%d members found, expected %d", dfnmem, dlnmem);
7767c478bd9Sstevel@tonic-gate 		err++;
7777c478bd9Sstevel@tonic-gate 	}
7787c478bd9Sstevel@tonic-gate 
7797c478bd9Sstevel@tonic-gate 	if (err > 0) {
7807c478bd9Sstevel@tonic-gate 		nvlist_free(nvl);
7817c478bd9Sstevel@tonic-gate 		return (NULL);
7827c478bd9Sstevel@tonic-gate 	}
7837c478bd9Sstevel@tonic-gate 
7847c478bd9Sstevel@tonic-gate 	return (nvl);
7857c478bd9Sstevel@tonic-gate }
7867c478bd9Sstevel@tonic-gate 
7877c478bd9Sstevel@tonic-gate /*
7887c478bd9Sstevel@tonic-gate  * The members have all been defined.  Validate the members against the
7897c478bd9Sstevel@tonic-gate  * declaration, and add it to the appropriate "defined" list.
7907c478bd9Sstevel@tonic-gate  */
7917c478bd9Sstevel@tonic-gate void
inj_defn_finish(inj_defn_t * defn,const char * declnm,const char * name,inj_itemtype_t type)7927c478bd9Sstevel@tonic-gate inj_defn_finish(inj_defn_t *defn, const char *declnm, const char *name,
7937c478bd9Sstevel@tonic-gate     inj_itemtype_t type)
7947c478bd9Sstevel@tonic-gate {
7957c478bd9Sstevel@tonic-gate 	inj_decl_t *decl = inj_decl_lookup(declnm, type);
7967c478bd9Sstevel@tonic-gate 	inj_hash_t *hash = item2hash(type);
7977c478bd9Sstevel@tonic-gate 	inj_declmem_t *dlm;
7987c478bd9Sstevel@tonic-gate 	inj_defnmem_t *dfm;
7997c478bd9Sstevel@tonic-gate 	inj_var_t *v;
8007c478bd9Sstevel@tonic-gate 
8017c478bd9Sstevel@tonic-gate 	defn->defn_name = name;
8027c478bd9Sstevel@tonic-gate 	defn->defn_decl = decl;
8037c478bd9Sstevel@tonic-gate 
8047c478bd9Sstevel@tonic-gate 	if (decl == NULL) {
8057c478bd9Sstevel@tonic-gate 		yyerror("unknown %s type %s\n", inj_item2str(type), declnm);
8067c478bd9Sstevel@tonic-gate 		inj_defn_destroy(defn);
8077c478bd9Sstevel@tonic-gate 		return;
8087c478bd9Sstevel@tonic-gate 	}
8097c478bd9Sstevel@tonic-gate 
8107c478bd9Sstevel@tonic-gate 	dlm = inj_list_next(&decl->decl_members);
8117c478bd9Sstevel@tonic-gate 	dfm = inj_list_next(&defn->defn_members);
8127c478bd9Sstevel@tonic-gate 
8137c478bd9Sstevel@tonic-gate 	if ((defn->defn_nvl = inj_defn_validate_memlist(dlm, dfm)) == NULL) {
8147c478bd9Sstevel@tonic-gate 		inj_defn_destroy(defn);
8157c478bd9Sstevel@tonic-gate 		return;
8167c478bd9Sstevel@tonic-gate 	}
8177c478bd9Sstevel@tonic-gate 
8187c478bd9Sstevel@tonic-gate 	if (type == ITEMTYPE_EVENT) {
8197c478bd9Sstevel@tonic-gate 		if ((errno = nvlist_add_string(defn->defn_nvl, "class",
8207c478bd9Sstevel@tonic-gate 		    (char *)defn->defn_decl->decl_name)) != 0)
8217c478bd9Sstevel@tonic-gate 			die("failed to add class to %s", name);
8227c478bd9Sstevel@tonic-gate 	}
8237c478bd9Sstevel@tonic-gate 
8247c478bd9Sstevel@tonic-gate 	if ((v = inj_strhash_lookup(hash, name)) != NULL) {
8257c478bd9Sstevel@tonic-gate 		inj_defn_t *other = inj_hash_get_cookie(v);
826