usr/src/cmd/fm/fminject/common/inj_defn.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*
  28  * After having been declared, events, FMRIs and authorities must be defined
  29  * (instantiated) before they can be used as the subjects of commands.
  30  */
  31
  32 #include <sys/sysmacros.h>
  33 #include <libnvpair.h>
  34 #include <string.h>
  35 #include <assert.h>
  36
  37 #include <inj_event.h>
  38 #include <inj_err.h>
  39 #include <inj_lex.h>
  40 #include <inj_string.h>
  41 #include <inj.h>
  42
  43 static inj_hash_t inj_defns[3];
  44 static int inj_defns_initialized;
  45
  46 /* Intrinsics (signed and unsigned integer integer constants) */
  47 typedef struct intr {
  48         uchar_t ei_signed;
  49         uchar_t ei_width;
  50 } intr_t;
  51
  52 static inj_hash_t *
  53 item2hash(inj_itemtype_t item)
  54 {
  55         int i;
  56
  57         assert(item >= 0 && item < sizeof (inj_defns) / sizeof (inj_hash_t));
  58
  59         if (!inj_defns_initialized) {
  60                 for (i = 0; i < sizeof (inj_defns) / sizeof (inj_hash_t); i++)
  61                         inj_strhash_create(&inj_defns[i]);
  62                 inj_defns_initialized = 1;
  63         }
  64
  65         return (&inj_defns[item]);
  66 }
  67
  68 inj_defn_t *
  69 inj_defn_lookup(const char *name, inj_memtype_t type)
  70 {
  71         inj_hash_t *hash = item2hash(inj_mem2item(type));
  72         inj_var_t *v;
  73
  74         if ((v = inj_strhash_lookup(hash, name)) == NULL)
  75                 return (NULL);
  76
  77         return (inj_hash_get_cookie(v));
  78 }
  79
  80 static void
  81 inj_defn_destroy_memlist(inj_defnmem_t *m)
  82 {
  83         inj_defnmem_t *n;
  84
  85         for (/* */; m != NULL; m = n) {
  86                 n = inj_list_next(m);
  87
  88                 switch (m->dfm_type) {
  89                 case DEFNMEM_ARRAY:
  90                 case DEFNMEM_LIST:
  91                         inj_defn_destroy_memlist(inj_list_next(&m->dfm_list));
  92                         break;
  93                 default:
  94                         inj_strfree(m->dfm_str);
  95                 }
  96         }
  97 }
  98
  99 void
 100 inj_defn_destroy(inj_defn_t *defn)
 101 {
 102         if (defn->defn_name != NULL)
 103                 inj_strfree(defn->defn_name);
 104
 105         nvlist_free(defn->defn_nvl);
 106
 107         inj_defn_destroy_memlist(inj_list_next(&defn->defn_members));
 108 }
 109
 110 static inj_defnmem_t *
 111 inj_defn_mem_create_common(inj_defnmemtype_t type)
 112 {
 113         inj_defnmem_t *dfm = inj_zalloc(sizeof (inj_defnmem_t));
 114
 115         dfm->dfm_type = type;
 116         dfm->dfm_lineno = yylineno;
 117
 118         return (dfm);
 119 }
 120
 121 inj_defnmem_t *
 122 inj_defn_mem_create(const char *str, inj_defnmemtype_t type)
 123 {
 124         inj_defnmem_t *dfm = inj_defn_mem_create_common(type);
 125
 126         dfm->dfm_str = str;
 127
 128         return (dfm);
 129 }
 130
 131 inj_defnmem_t *
 132 inj_defn_mem_create_list(inj_defn_t *list, inj_defnmemtype_t type)
 133 {
 134         inj_defnmem_t *dfm = inj_defn_mem_create_common(type);
 135
 136         dfm->dfm_list = list->defn_members;
 137
 138         inj_free(list, sizeof (inj_defn_t));
 139
 140         return (dfm);
 141 }
 142
 143 inj_defn_t *
 144 inj_defn_create(inj_defnmem_t *dfm)
 145 {
 146         inj_defn_t *defn = inj_zalloc(sizeof (inj_defn_t));
 147
 148         defn->defn_lineno = yylineno;
 149
 150         inj_list_append(&defn->defn_members, dfm);
 151
 152         return (defn);
 153 }
 154
 155 void
 156 inj_defn_addmem(inj_defn_t *defn, inj_defnmem_t *dfm)
 157 {
 158         inj_list_append(&defn->defn_members, dfm);
 159 }
 160
 161 /*
 162  * Validate the dimensions of an array.  If the declared array size was zero,
 163  * accept (and return) whatever the definition used.  If fewer cells were
 164  * defined than were declared, return the declared size - the calling code will
 165  * fill the remaining cells with zeros.  The definition of more than the
 166  * declared number of cells triggers an error.  We print and error message in
 167  * this case and return the declared number.  This will allow processing to
 168  * continue.  The act of emitting the error will guarantee that we never
 169  * pass from parsing to program execution.
 170  */
 171 static size_t
 172 array_dim_check(inj_declmem_t *dlm, inj_defnmem_t *dfm)
 173 {
 174         inj_list_t *l;
 175         size_t dfnelems;
 176
 177         for (dfnelems = 0, l = inj_list_next(&dfm->dfm_list); l != NULL;
 178             l = inj_list_next(l), dfnelems++);
 179
 180         if (dlm->dlm_arrdim != 0 && dlm->dlm_arrdim != dfnelems) {
 181                 yyerror(" %d: defined array has %d elements, expected %d\n",
 182                     dfm->dfm_lineno, dfnelems, dlm->dlm_arrdim);
 183                 dfnelems = dlm->dlm_arrdim;
 184         }
 185
 186         return (MAX(dfnelems, dlm->dlm_arrdim));
 187 }
 188
 189 /*
 190  * The inj_defn_memcmp_* routines serve two purposes.  First, they compare a
 191  * given defined member with the corresponding declared member, signalling an
 192  * error if the two are incompatible.
 193  *
 194  * Assuming that validation succeeds, an entry is added to the passed nvlist
 195  * for the defined member.
 196  */
 197
 198 /* Used to ease signed and unsigned integer validation */
 199 static const intr_t inj_intrinsics[] = {
 200         { 0, 0 }, /* MEMTYPE_UNKNOWN */
 201         { 1, 8 }, { 1, 16 }, { 1, 32 }, { 1, 64 },
 202         { 0, 8 }, { 0, 16 }, { 0, 32 }, { 0, 64 }
 203 };
 204
 205 static int
 206 inj_defn_memcmp_signed(const intr_t *intr, inj_declmem_t *dlm,
 207     inj_defnmem_t *dfm, nvlist_t *nvl)
 208 {
 209         longlong_t val;
 210
 211         if (dfm->dfm_type != DEFNMEM_IMM && dfm->dfm_type != DEFNMEM_IDENT)
 212                 return (inj_set_errno(EINVAL));
 213
 214         if (inj_strtoll(dfm->dfm_str, intr->ei_width, &val) < 0)
 215                 return (-1); /* errno is set for us */
 216
 217         switch (dlm->dlm_type) {
 218         case MEMTYPE_INT8:
 219                 errno = nvlist_add_int8(nvl, (char *)dlm->dlm_name,
 220                     (int8_t)val);
 221                 break;
 222         case MEMTYPE_INT16:
 223                 errno = nvlist_add_int16(nvl, (char *)dlm->dlm_name,
 224                     (int16_t)val);
 225                 break;
 226         case MEMTYPE_INT32:
 227                 errno = nvlist_add_int32(nvl, (char *)dlm->dlm_name,
 228                     (int32_t)val);
 229                 break;
 230         case MEMTYPE_INT64:
 231                 errno = nvlist_add_int64(nvl, (char *)dlm->dlm_name,
 232                     (int64_t)val);
 233         }
 234
 235         if (errno != 0)
 236                 die("failed to add member %s\n", dlm->dlm_name);
 237
 238         return (0);
 239 }
 240
 241 static int
 242 inj_defn_memcmp_unsigned(const intr_t *intr, inj_declmem_t *dlm,
 243     inj_defnmem_t *dfm, nvlist_t *nvl)
 244 {
 245         u_longlong_t val;
 246
 247         if (dfm->dfm_type != DEFNMEM_IMM && dfm->dfm_type != DEFNMEM_IDENT)
 248                 return (inj_set_errno(EINVAL));
 249
 250         if (inj_strtoull(dfm->dfm_str, intr->ei_width, &val) < 0)
 251                 return (-1); /* errno is set for us */
 252
 253         switch (dlm->dlm_type) {
 254         case MEMTYPE_UINT8:
 255                 errno = nvlist_add_uint8(nvl, (char *)dlm->dlm_name,
 256                     (uint8_t)val);
 257                 break;
 258         case MEMTYPE_UINT16:
 259                 errno = nvlist_add_uint16(nvl, (char *)dlm->dlm_name,
 260                     (uint16_t)val);
 261                 break;
 262         case MEMTYPE_UINT32:
 263                 errno = nvlist_add_uint32(nvl, (char *)dlm->dlm_name,
 264                     (uint32_t)val);
 265                 break;
 266         case MEMTYPE_UINT64:
 267                 errno = nvlist_add_uint64(nvl, (char *)dlm->dlm_name,
 268                     (uint64_t)val);
 269         }
 270
 271         if (errno != 0)
 272                 die("failed to add member %s\n", dlm->dlm_name);
 273
 274         return (0);
 275 }
 276
 277 /* Validate an array of (un)signed integers. */
 278 static int
 279 inj_defn_memcmp_intr_array(const intr_t *cont, inj_declmem_t *dlm,
 280     inj_defnmem_t *dfm, nvlist_t *nvl)
 281 {
 282         typedef int (*adder_t)();
 283         static const adder_t signed_adders[] = {
 284                 NULL, nvlist_add_int8_array, nvlist_add_int16_array,
 285                 NULL, nvlist_add_int32_array, NULL, NULL, NULL,
 286                 nvlist_add_int64_array
 287         };
 288         static const adder_t unsigned_adders[] = {
 289                 NULL,
 290                 nvlist_add_uint8_array, nvlist_add_uint16_array,
 291                 NULL, nvlist_add_uint32_array, NULL, NULL, NULL,
 292                 nvlist_add_uint64_array
 293         };
 294
 295         union {
 296                 char *a;
 297                 int8_t *a8; uint8_t *au8;
 298                 int16_t *a16; uint16_t *au16;
 299                 int32_t *a32; uint32_t *au32;
 300                 int64_t *a64; uint64_t *au64;
 301         } a;
 302
 303         int (*adder)(nvlist_t *, const char *, char *, uint_t);
 304         size_t nelems;
 305         inj_defnmem_t *elem;
 306         char *arrbase, *arr;
 307         size_t arrsz;
 308         int err = 0;
 309         int i;
 310
 311         if (dfm->dfm_type != DEFNMEM_ARRAY)
 312                 return (inj_set_errno(EINVAL));
 313
 314         /*
 315          * Each nvlist array adder wants an array of its own type as input,
 316          * which is reasonable, but it complicates our general implementation.
 317          * We fight back with casting magic.
 318          */
 319
 320         nelems = array_dim_check(dlm, dfm);
 321         arrsz = (nelems + 1) * (cont->ei_width / NBBY);
 322         arrbase = inj_zalloc(arrsz);
 323         a.a = arr = (char *)P2ROUNDUP((uintptr_t)arrbase,
 324             cont->ei_width / NBBY);
 325
 326         adder = (cont->ei_signed ? signed_adders :
 327             unsigned_adders)[cont->ei_width / NBBY];
 328         assert(adder != NULL);
 329
 330         for (i = 1, elem = inj_list_next(&dfm->dfm_list); elem != NULL;
 331             elem = inj_list_next(elem), i++) {
 332                 if (elem->dfm_type != DEFNMEM_IMM &&
 333                     elem->dfm_type != DEFNMEM_IDENT) {
 334                         yyerror(" %d: array cell %d is invalid\n",
 335                             dfm->dfm_lineno, i);
 336                         err++;
 337                         continue;
 338                 }
 339
 340                 if (cont->ei_signed) {
 341                         longlong_t val;
 342
 343                         if (inj_strtoll(elem->dfm_str, cont->ei_width,
 344                             &val) < 0) {
 345                                 yyerror(" %d: array cell %d %s\n",
 346                                     dfm->dfm_lineno, i, (errno == ERANGE ?
 347                                     "out of range for type" : "invalid"));
 348                                 err++;
 349                                 continue;
 350                         }
 351
 352                         switch (cont->ei_width) {
 353                         case 8:
 354                                 *a.a8++ = (int8_t)val;
 355                                 break;
 356                         case 16:
 357                                 *a.a16++ = (int16_t)val;
 358                                 break;
 359                         case 32:
 360                                 *a.a32++ = (int32_t)val;
 361                                 break;
 362                         default:
 363                                 *a.a64++ = (int64_t)val;
 364                         }
 365
 366                 } else {
 367                         u_longlong_t val;
 368
 369                         if (inj_strtoull(elem->dfm_str, cont->ei_width,
 370                             &val) < 0) {
 371                                 yyerror(" %d: array cell %d %s\n",
 372                                     dfm->dfm_lineno, i, (errno == ERANGE ?
 373                                     "out of range for type" : "invalid"));
 374                                 err++;
 375                                 continue;
 376                         }
 377
 378                         switch (cont->ei_width) {
 379                         case 8:
 380                                 *a.au8++ = (uint8_t)val;
 381                                 break;
 382                         case 16:
 383                                 *a.au16++ = (uint16_t)val;
 384                                 break;
 385                         case 32:
 386                                 *a.au32++ = (uint32_t)val;
 387                                 break;
 388                         default:
 389                                 *a.au64++ = (uint64_t)val;
 390                         }
 391                 }
 392         }
 393
 394         if (err == 0 && (errno = adder(nvl, dlm->dlm_name, arr, nelems)) != 0)
 395                 die("failed to add array member %s", dlm->dlm_name);
 396
 397         inj_free(arrbase, arrsz);
 398
 399         if (err != 0)
 400                 return (inj_set_errno(EINVAL));
 401
 402         return (0);
 403 }
 404
 405 static int
 406 bool2val(const char *str, boolean_t *valp)
 407 {
 408         if (strcasecmp(str, "true") == 0)
 409                 *valp = 1;
 410         else if (strcasecmp(str, "false") == 0)
 411                 *valp = 0;
 412         else
 413                 return (-1);
 414
 415         return (0);
 416 }
 417
 418 static int
 419 inj_defn_memcmp_bool(inj_declmem_t *dlm, inj_defnmem_t *dfm, nvlist_t *nvl)
 420 {
 421         boolean_t val;
 422
 423         if (dfm->dfm_type != DEFNMEM_IDENT)
 424                 return (inj_set_errno(EINVAL));
 425
 426         if (bool2val(dfm->dfm_str, &val) < 0)
 427                 return (inj_set_errno(EINVAL));
 428
 429         if ((errno = nvlist_add_boolean_value(nvl, (char *)dlm->dlm_name,
 430             val)) != 0)
 431                 die("failed to add boolean member %s", dlm->dlm_name);
 432
 433         return (0);
 434 }
 435
 436 static int
 437 inj_defn_memcmp_bool_array(inj_declmem_t *dlm, inj_defnmem_t *dfm,
 438     nvlist_t *nvl)
 439 {
 440         inj_defnmem_t *elem;
 441         boolean_t *arr;
 442         size_t nelems, arrsz;
 443         int err = 0;
 444         int i;
 445
 446         if (dfm->dfm_type != DEFNMEM_ARRAY)
 447                 return (inj_set_errno(EINVAL));
 448
 449         nelems = array_dim_check(dlm, dfm);
 450         arrsz = nelems * sizeof (boolean_t);
 451         arr = inj_zalloc(arrsz);
 452
 453         for (i = 0, elem = inj_list_next(&dfm->dfm_list); elem != NULL;
 454             elem = inj_list_next(elem), i++) {
 455                 if (elem->dfm_type != DEFNMEM_IDENT) {
 456                         yyerror(" %d: array cell %d is invalid\n",
 457                             dfm->dfm_lineno, i + 1);
 458                         err++;
 459                         continue;
 460                 }
 461
 462                 if (bool2val(elem->dfm_str, &arr[i]) < 0)
 463                         return (inj_set_errno(EINVAL));
 464         }
 465
 466         if (err == 0 && (errno = nvlist_add_boolean_array(nvl,
 467             (char *)dlm->dlm_name, arr, nelems)) != 0)
 468                 die("failed to add boolean array member %s", dlm->dlm_name);
 469
 470         inj_free(arr, arrsz);
 471
 472         return (0);
 473 }
 474
 475 /* Used for both strings and enums */
 476 static int
 477 inj_defn_memcmp_strenum(inj_declmem_t *dlm, inj_defnmem_t *dfm, nvlist_t *nvl)
 478 {
 479         inj_defnmemtype_t defnmemtype = (dlm->dlm_type == MEMTYPE_ENUM ?
 480             DEFNMEM_IDENT : DEFNMEM_QSTRING);
 481         const char *strenum = (dlm->dlm_type == MEMTYPE_ENUM ? "enum" :
 482             "string");
 483
 484         if (dfm->dfm_type != defnmemtype)
 485                 return (inj_set_errno(EINVAL));
 486
 487         if ((errno = nvlist_add_string(nvl, (char *)dlm->dlm_name,
 488             (char *)dfm->dfm_str)) != 0)
 489                 die("failed to add %s member %s", strenum, dlm->dlm_name);
 490
 491         return (0);
 492 }
 493
 494 static int
 495 inj_defn_memcmp_strenum_array(inj_declmem_t *dlm, inj_defnmem_t *dfm,
 496     nvlist_t *nvl)
 497 {
 498         inj_defnmemtype_t defnmemtype = (dlm->dlm_type == MEMTYPE_ENUM ?
 499             DEFNMEM_IDENT : DEFNMEM_QSTRING);
 500         const char *strenum = (dlm->dlm_type == MEMTYPE_ENUM ? "enum" :
 501             "string");
 502
 503         inj_defnmem_t *elem;
 504         size_t nelems, arrsz;
 505         const char **arr;
 506         int err = 0;
 507         int i;
 508
 509         if (dfm->dfm_type != DEFNMEM_ARRAY)
 510                 return (inj_set_errno(EINVAL));
 511
 512         nelems = array_dim_check(dlm, dfm);
 513         arrsz = nelems * sizeof (char *);
 514         arr = inj_zalloc(arrsz);
 515
 516         for (i = 0, elem = inj_list_next(&dfm->dfm_list); elem != NULL;
 517             elem = inj_list_next(elem), i++) {
 518                 if (elem->dfm_type != defnmemtype) {
 519                         yyerror(" %d: array cell %d is invalid\n",
 520                             dfm->dfm_lineno, i + 1);
 521                         err++;
 522                         continue;
 523                 }
 524
 525                 if (dlm->dlm_type == MEMTYPE_ENUM &&
 526                     inj_strhash_lookup(dlm->dlm_enumvals, elem->dfm_str) ==
 527                     NULL) {
 528                         yyerror(" %d: invalid enum value %s\n",
 529                             dfm->dfm_lineno, elem->dfm_str);
 530                         err++;
 531                         continue;
 532                 }
 533
 534                 arr[i] = elem->dfm_str;
 535         }
 536
 537         if (err == 0 && (errno = nvlist_add_string_array(nvl,
 538             dlm->dlm_name, (char **)arr, nelems)) != 0)
 539                 die("failed to add %s array member %s", strenum, dlm->dlm_name);
 540
 541         inj_free(arr, arrsz);
 542         return (0);
 543 }
 544
 545 /*
 546  * Validator for embedded lists (events, fmris, authorities, lists, etc.).
 547  * There are two cases to deal with here.  The user could either have provided
 548  * the name of a previously-defined list, in which case we just make a copy of
 549  * said list for insertion into ours.  Alternatively, the user could simply
 550  * define a new list here.  In that case, we recursively invoke the member
 551  * comparator, but against the list type for the member being defined.
 552  */
 553 static nvlist_t *inj_defn_validate_memlist(inj_declmem_t *, inj_defnmem_t *);
 554
 555 /* Embedded definition */
 556 static nvlist_t *
 557 inj_defn_memcmp_sub_list(inj_declmem_t *dlm, inj_defnmem_t *dfm)
 558 {
 559         inj_declmem_t *subdlm = inj_list_next(&dlm->dlm_decl->decl_members);
 560         inj_defnmem_t *subdfm = inj_list_next(&dfm->dfm_list);
 561
 562         return (inj_defn_validate_memlist(subdlm, subdfm));
 563 }
 564
 565 /* Reference to previously-defined thing */
 566 static nvlist_t *
 567 inj_defn_memcmp_sub_defined(inj_declmem_t *dlm, inj_defnmem_t *dfm)
 568 {
 569         inj_defn_t *subdefn;
 570         nvlist_t *new;
 571
 572         if ((subdefn = inj_defn_lookup(dfm->dfm_str, dlm->dlm_type)) == NULL) {
 573                 yyerror(" %d: reference to undefined %s %s\n", dfm->dfm_lineno,
 574                     inj_mem2str(dlm->dlm_type), dfm->dfm_str);
 575                 (void) inj_set_errno(EINVAL);
 576                 return (NULL);
 577         }
 578
 579         if (subdefn->defn_decl != dlm->dlm_decl) {
 580                 yyerror(" %d: %s %s is not a(n) %s\n", dfm->dfm_lineno,
 581                     inj_mem2str(dlm->dlm_type), dfm->dfm_str,
 582                     subdefn->defn_decl->decl_name);
 583                 (void) inj_set_errno(EINVAL);
 584                 return (NULL);
 585         }
 586
 587         assert(subdefn->defn_nvl != NULL);
 588
 589         if ((errno = nvlist_dup(subdefn->defn_nvl, &new, 0)) != 0) {
 590                 die("failed to duplicate %s list %s",
 591                     inj_item2str(subdefn->defn_decl->decl_type), dfm->dfm_str);
 592         }
 593
 594         return (new);
 595 }
 596
 597 static nvlist_t *
 598 inj_defn_memcmp_sub_makenvl(inj_declmem_t *dlm, inj_defnmem_t *dfm)
 599 {
 600         inj_defnmemtype_t dftype = dfm->dfm_type;
 601         inj_memtype_t dltype = dlm->dlm_type;
 602         nvlist_t *new = NULL;
 603
 604         if (dftype == DEFNMEM_LIST)
 605                 new = inj_defn_memcmp_sub_list(dlm, dfm);
 606         else if (dftype == DEFNMEM_IDENT && (dltype == MEMTYPE_EVENT ||
 607             dltype == MEMTYPE_FMRI || dltype == MEMTYPE_AUTH))
 608                 new = inj_defn_memcmp_sub_defined(dlm, dfm);
 609         else
 610                 (void) inj_set_errno(EINVAL);
 611
 612         return (new);
 613 }
 614
 615 /* A single sub-list */
 616 static int
 617 inj_defn_memcmp_sub(inj_declmem_t *dlm, inj_defnmem_t *dfm, nvlist_t *nvl)
 618 {
 619         nvlist_t *new;
 620
 621         if ((new = inj_defn_memcmp_sub_makenvl(dlm, dfm)) == NULL)
 622                 return (-1); /* errno is set for us */
 623
 624         if ((errno = nvlist_add_nvlist(nvl, (char *)dlm->dlm_name,
 625             new)) != 0)
 626                 die("failed to add list member %s", dlm->dlm_name);
 627
 628         return (0);
 629 }
 630
 631 /* An array of sub-lists (for example, an array of events of a given type) */
 632 static int
 633 inj_defn_memcmp_sub_array(inj_declmem_t *dlm, inj_defnmem_t *dfm, nvlist_t *nvl)
 634 {
 635         size_t nelems, arrsz;
 636         inj_defnmem_t *elem;
 637         nvlist_t **arr;
 638         int err = 0;
 639         int i;
 640
 641         if (dfm->dfm_type != DEFNMEM_ARRAY)
 642                 return (inj_set_errno(EINVAL));
 643
 644         nelems = array_dim_check(dlm, dfm);
 645         arrsz = nelems * sizeof (char *);
 646         arr = inj_zalloc(arrsz);
 647
 648         for (i = 0, elem = inj_list_next(&dfm->dfm_list); elem != NULL;
 649             elem = inj_list_next(elem), i++) {
 650                 if ((arr[i] = inj_defn_memcmp_sub_makenvl(dlm, elem)) == NULL) {
 651                         yyerror(" %d: array cell %d is invalid\n",
 652                             elem->dfm_lineno, i + 1);
 653                         err++;
 654                         continue;
 655                 }
 656         }
 657
 658         if (err == 0 && (errno = nvlist_add_nvlist_array(nvl,
 659             (char *)dlm->dlm_name, arr, nelems)) != 0)
 660                 die("failed to add nvlist list member %s", dlm->dlm_name);
 661
 662         inj_free(arr, arrsz);
 663
 664         return (0);
 665 }
 666
 667 /*
 668  * The declaration-definition member comparator.  Designed to recursive
 669  * invocation to allow for the validation of embedded/referenced lists.
 670  */
 671 nvlist_t *
 672 inj_defn_validate_memlist(inj_declmem_t *dlm, inj_defnmem_t *dfm)
 673 {
 674         const intr_t *intr;
 675         nvlist_t *nvl;
 676         int rc, nmem, dlnmem, dfnmem;
 677         int err = 0;
 678
 679         if ((errno = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) != 0)
 680                 die("failed to allocate nvl for event");
 681
 682         for (nmem = 1; dlm != NULL && dfm != NULL;
 683             dlm = inj_list_next(dlm), dfm = inj_list_next(dfm), nmem++) {
 684
 685                 switch (dlm->dlm_type) {
 686                 case MEMTYPE_INT8:
 687                 case MEMTYPE_INT16:
 688                 case MEMTYPE_INT32:
 689                 case MEMTYPE_INT64:
 690                         intr = &inj_intrinsics[dlm->dlm_type];
 691
 692                         if (dlm->dlm_flags & DECLMEM_F_ARRAY) {
 693                                 rc = inj_defn_memcmp_intr_array(intr, dlm, dfm,
 694                                     nvl);
 695                         } else {
 696                                 rc = inj_defn_memcmp_signed(intr, dlm, dfm,
 697                                     nvl);
 698                         }
 699                         break;
 700
 701                 case MEMTYPE_UINT8:
 702                 case MEMTYPE_UINT16:
 703                 case MEMTYPE_UINT32:
 704                 case MEMTYPE_UINT64:
 705                         intr = &inj_intrinsics[dlm->dlm_type];
 706
 707                         if (dlm->dlm_flags & DECLMEM_F_ARRAY) {
 708                                 rc = inj_defn_memcmp_intr_array(intr, dlm, dfm,
 709                                     nvl);
 710                         } else {
 711                                 rc = inj_defn_memcmp_unsigned(intr, dlm, dfm,
 712                                     nvl);
 713                         }
 714                         break;
 715
 716                 case MEMTYPE_BOOL:
 717                         if (dlm->dlm_flags & DECLMEM_F_ARRAY)
 718                                 rc = inj_defn_memcmp_bool_array(dlm, dfm, nvl);
 719                         else
 720                                 rc = inj_defn_memcmp_bool(dlm, dfm, nvl);
 721                         break;
 722
 723                 case MEMTYPE_STRING:
 724                         if (dlm->dlm_flags & DECLMEM_F_ARRAY) {
 725                                 rc = inj_defn_memcmp_strenum_array(dlm, dfm,
 726                                     nvl);
 727                         } else
 728                                 rc = inj_defn_memcmp_strenum(dlm, dfm, nvl);
 729                         break;
 730
 731                 case MEMTYPE_ENUM:
 732                         if (dlm->dlm_flags & DECLMEM_F_ARRAY) {
 733                                 rc = inj_defn_memcmp_strenum_array(dlm, dfm,
 734                                     nvl);
 735                         } else
 736                                 rc = inj_defn_memcmp_strenum(dlm, dfm, nvl);
 737                         break;
 738
 739                 case MEMTYPE_EVENT:
 740                 case MEMTYPE_FMRI:
 741                 case MEMTYPE_AUTH:
 742                 case MEMTYPE_LIST:
 743                         if (dlm->dlm_flags & DECLMEM_F_ARRAY)
 744                                 rc = inj_defn_memcmp_sub_array(dlm, dfm, nvl);
 745                         else
 746                                 rc = inj_defn_memcmp_sub(dlm, dfm, nvl);
 747                         break;
 748
 749                 default:
 750                         die("unknown decl member type %d on member %s\n",
 751                             dlm->dlm_type, dlm->dlm_name);
 752                 }
 753
 754                 if (rc < 0) {
 755                         yyerror(" %d: %s for member %s\n", dfm->dfm_lineno,
 756                             (errno == ERANGE ? "value out of range" :
 757                             "invalid value"), dlm->dlm_name);
 758                         err++;
 759                 }
 760         }
 761
 762         dlnmem = dfnmem = nmem;
 763
 764         while (dlm != NULL) {
 765                 dlm = inj_list_next(dlm);
 766                 dlnmem++;
 767         }
 768
 769         while (dfm != NULL) {
 770                 dfm = inj_list_next(dfm);
 771                 dfnmem++;
 772         }
 773
 774         if (dlnmem != dfnmem) {
 775                 yyerror("%d members found, expected %d", dfnmem, dlnmem);
 776                 err++;
 777         }
 778
 779         if (err > 0) {
 780                 nvlist_free(nvl);
 781                 return (NULL);
 782         }
 783
 784         return (nvl);
 785 }
 786
 787 /*
 788  * The members have all been defined.  Validate the members against the
 789  * declaration, and add it to the appropriate "defined" list.
 790  */
 791 void
 792 inj_defn_finish(inj_defn_t *defn, const char *declnm, const char *name,
 793     inj_itemtype_t type)
 794 {
 795         inj_decl_t *decl = inj_decl_lookup(declnm, type);
 796         inj_hash_t *hash = item2hash(type);
 797         inj_declmem_t *dlm;
 798         inj_defnmem_t *dfm;
 799         inj_var_t *v;
 800
 801         defn->defn_name = name;
 802         defn->defn_decl = decl;
 803
 804         if (decl == NULL) {
 805                 yyerror("unknown %s type %s\n", inj_item2str(type), declnm);
 806                 inj_defn_destroy(defn);
 807                 return;
 808         }
 809
 810         dlm = inj_list_next(&decl->decl_members);
 811         dfm = inj_list_next(&defn->defn_members);
 812
 813         if ((defn->defn_nvl = inj_defn_validate_memlist(dlm, dfm)) == NULL) {
 814                 inj_defn_destroy(defn);
 815                 return;
 816         }
 817
 818         if (type == ITEMTYPE_EVENT) {
 819                 if ((errno = nvlist_add_string(defn->defn_nvl, "class",
 820                     (char *)defn->defn_decl->decl_name)) != 0)
 821                         die("failed to add class to %s", name);
 822         }
 823
 824         if ((v = inj_strhash_lookup(hash, name)) != NULL) {
 825                 inj_defn_t *other = inj_hash_get_cookie(v);
 826
 827                 yyerror("duplicate %s name %s (other on line %d)\n",
 828                     inj_item2str(type), name, other->defn_lineno);
 829                 inj_defn_destroy(defn);
 830                 return;
 831         }
 832
 833         (void) inj_strhash_insert(hash, name, (uintptr_t)defn);
 834 }