module/nvpair/nvpair.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 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 #include <sys/stropts.h>
  30 #include <sys/debug.h>
  31 #include <sys/isa_defs.h>
  32 #include <sys/int_limits.h>
  33 #include <sys/nvpair.h>
  34 #include <sys/nvpair_impl.h>
  35 #include <rpc/types.h>
  36 #include <rpc/xdr.h>
  37
  38 #if defined(_KERNEL) && !defined(_BOOT)
  39 #include <sys/varargs.h>
  40 #include <sys/ddi.h>
  41 #include <sys/sunddi.h>
  42 #else
  43 #include <stdarg.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <strings.h>
  47 #endif
  48
  49 #ifndef offsetof
  50 #define offsetof(s, m)          ((size_t)(&(((s *)0)->m)))
  51 #endif
  52 #define skip_whitespace(p)      while ((*(p) == ' ') || (*(p) == '\t')) p++
  53
  54 /*
  55  * nvpair.c - Provides kernel & userland interfaces for manipulating
  56  *      name-value pairs.
  57  *
  58  * Overview Diagram
  59  *
  60  *  +--------------+
  61  *  |  nvlist_t    |
  62  *  |--------------|
  63  *  | nvl_version  |
  64  *  | nvl_nvflag   |
  65  *  | nvl_priv    -+-+
  66  *  | nvl_flag     | |
  67  *  | nvl_pad      | |
  68  *  +--------------+ |
  69  *                   V
  70  *      +--------------+      last i_nvp in list
  71  *      | nvpriv_t     |  +--------------------->
  72  *      |--------------|  |
  73  *   +--+- nvp_list    |  |   +------------+
  74  *   |  |  nvp_last   -+--+   + nv_alloc_t |
  75  *   |  |  nvp_curr    |      |------------|
  76  *   |  |  nvp_nva    -+----> | nva_ops    |
  77  *   |  |  nvp_stat    |      | nva_arg    |
  78  *   |  +--------------+      +------------+
  79  *   |
  80  *   +-------+
  81  *           V
  82  *   +---------------------+      +-------------------+
  83  *   |  i_nvp_t            |  +-->|  i_nvp_t          |  +-->
  84  *   |---------------------|  |   |-------------------|  |
  85  *   | nvi_next           -+--+   | nvi_next         -+--+
  86  *   | nvi_prev (NULL)     | <----+ nvi_prev          |
  87  *   | . . . . . . . . . . |      | . . . . . . . . . |
  88  *   | nvp (nvpair_t)      |      | nvp (nvpair_t)    |
  89  *   |  - nvp_size         |      |  - nvp_size       |
  90  *   |  - nvp_name_sz      |      |  - nvp_name_sz    |
  91  *   |  - nvp_value_elem   |      |  - nvp_value_elem |
  92  *   |  - nvp_type         |      |  - nvp_type       |
  93  *   |  - data ...         |      |  - data ...       |
  94  *   +---------------------+      +-------------------+
  95  *
  96  *
  97  *
  98  *   +---------------------+              +---------------------+
  99  *   |  i_nvp_t            |  +-->    +-->|  i_nvp_t (last)     |
 100  *   |---------------------|  |       |   |---------------------|
 101  *   |  nvi_next          -+--+ ... --+   | nvi_next (NULL)     |
 102  * <-+- nvi_prev           |<-- ...  <----+ nvi_prev            |
 103  *   | . . . . . . . . .   |              | . . . . . . . . .   |
 104  *   | nvp (nvpair_t)      |              | nvp (nvpair_t)      |
 105  *   |  - nvp_size         |              |  - nvp_size         |
 106  *   |  - nvp_name_sz      |              |  - nvp_name_sz      |
 107  *   |  - nvp_value_elem   |              |  - nvp_value_elem   |
 108  *   |  - DATA_TYPE_NVLIST |              |  - nvp_type         |
 109  *   |  - data (embedded)  |              |  - data ...         |
 110  *   |    nvlist name      |              +---------------------+
 111  *   |  +--------------+   |
 112  *   |  |  nvlist_t    |   |
 113  *   |  |--------------|   |
 114  *   |  | nvl_version  |   |
 115  *   |  | nvl_nvflag   |   |
 116  *   |  | nvl_priv   --+---+---->
 117  *   |  | nvl_flag     |   |
 118  *   |  | nvl_pad      |   |
 119  *   |  +--------------+   |
 120  *   +---------------------+
 121  *
 122  *
 123  * N.B. nvpair_t may be aligned on 4 byte boundary, so +4 will
 124  * allow value to be aligned on 8 byte boundary
 125  *
 126  * name_len is the length of the name string including the null terminator
 127  * so it must be >= 1
 128  */
 129 #define NVP_SIZE_CALC(name_len, data_len) \
 130         (NV_ALIGN((sizeof (nvpair_t)) + name_len) + NV_ALIGN(data_len))
 131
 132 static int i_get_value_size(data_type_t type, const void *data, uint_t nelem);
 133 static int nvlist_add_common(nvlist_t *nvl, const char *name, data_type_t type,
 134     uint_t nelem, const void *data);
 135
 136 #define NV_STAT_EMBEDDED        0x1
 137 #define EMBEDDED_NVL(nvp)       ((nvlist_t *)(void *)NVP_VALUE(nvp))
 138 #define EMBEDDED_NVL_ARRAY(nvp) ((nvlist_t **)(void *)NVP_VALUE(nvp))
 139
 140 #define NVP_VALOFF(nvp) (NV_ALIGN(sizeof (nvpair_t) + (nvp)->nvp_name_sz))
 141 #define NVPAIR2I_NVP(nvp) \
 142         ((i_nvp_t *)((size_t)(nvp) - offsetof(i_nvp_t, nvi_nvp)))
 143
 144
 145 int
 146 nv_alloc_init(nv_alloc_t *nva, const nv_alloc_ops_t *nvo, /* args */ ...)
 147 {
 148         va_list valist;
 149         int err = 0;
 150
 151         nva->nva_ops = nvo;
 152         nva->nva_arg = NULL;
 153
 154         va_start(valist, nvo);
 155         if (nva->nva_ops->nv_ao_init != NULL)
 156                 err = nva->nva_ops->nv_ao_init(nva, valist);
 157         va_end(valist);
 158
 159         return (err);
 160 }
 161
 162 void
 163 nv_alloc_reset(nv_alloc_t *nva)
 164 {
 165         if (nva->nva_ops->nv_ao_reset != NULL)
 166                 nva->nva_ops->nv_ao_reset(nva);
 167 }
 168
 169 void
 170 nv_alloc_fini(nv_alloc_t *nva)
 171 {
 172         if (nva->nva_ops->nv_ao_fini != NULL)
 173                 nva->nva_ops->nv_ao_fini(nva);
 174 }
 175
 176 nv_alloc_t *
 177 nvlist_lookup_nv_alloc(nvlist_t *nvl)
 178 {
 179         nvpriv_t *priv;
 180
 181         if (nvl == NULL ||
 182             (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
 183                 return (NULL);
 184
 185         return (priv->nvp_nva);
 186 }
 187
 188 static void *
 189 nv_mem_zalloc(nvpriv_t *nvp, size_t size)
 190 {
 191         nv_alloc_t *nva = nvp->nvp_nva;
 192         void *buf;
 193
 194         if ((buf = nva->nva_ops->nv_ao_alloc(nva, size)) != NULL)
 195                 bzero(buf, size);
 196
 197         return (buf);
 198 }
 199
 200 static void
 201 nv_mem_free(nvpriv_t *nvp, void *buf, size_t size)
 202 {
 203         nv_alloc_t *nva = nvp->nvp_nva;
 204
 205         nva->nva_ops->nv_ao_free(nva, buf, size);
 206 }
 207
 208 static void
 209 nv_priv_init(nvpriv_t *priv, nv_alloc_t *nva, uint32_t stat)
 210 {
 211         bzero(priv, sizeof (nvpriv_t));
 212
 213         priv->nvp_nva = nva;
 214         priv->nvp_stat = stat;
 215 }
 216
 217 static nvpriv_t *
 218 nv_priv_alloc(nv_alloc_t *nva)
 219 {
 220         nvpriv_t *priv;
 221
 222         /*
 223          * nv_mem_alloc() cannot called here because it needs the priv
 224          * argument.
 225          */
 226         if ((priv = nva->nva_ops->nv_ao_alloc(nva, sizeof (nvpriv_t))) == NULL)
 227                 return (NULL);
 228
 229         nv_priv_init(priv, nva, 0);
 230
 231         return (priv);
 232 }
 233
 234 /*
 235  * Embedded lists need their own nvpriv_t's.  We create a new
 236  * nvpriv_t using the parameters and allocator from the parent
 237  * list's nvpriv_t.
 238  */
 239 static nvpriv_t *
 240 nv_priv_alloc_embedded(nvpriv_t *priv)
 241 {
 242         nvpriv_t *emb_priv;
 243
 244         if ((emb_priv = nv_mem_zalloc(priv, sizeof (nvpriv_t))) == NULL)
 245                 return (NULL);
 246
 247         nv_priv_init(emb_priv, priv->nvp_nva, NV_STAT_EMBEDDED);
 248
 249         return (emb_priv);
 250 }
 251
 252 static void
 253 nvlist_init(nvlist_t *nvl, uint32_t nvflag, nvpriv_t *priv)
 254 {
 255         nvl->nvl_version = NV_VERSION;
 256         nvl->nvl_nvflag = nvflag & (NV_UNIQUE_NAME|NV_UNIQUE_NAME_TYPE);
 257         nvl->nvl_priv = (uint64_t)(uintptr_t)priv;
 258         nvl->nvl_flag = 0;
 259         nvl->nvl_pad = 0;
 260 }
 261
 262 /*
 263  * nvlist_alloc - Allocate nvlist.
 264  */
 265 /*ARGSUSED1*/
 266 int
 267 nvlist_alloc(nvlist_t **nvlp, uint_t nvflag, int kmflag)
 268 {
 269 #if defined(_KERNEL) && !defined(_BOOT)
 270         return (nvlist_xalloc(nvlp, nvflag,
 271             (kmflag == KM_SLEEP ? nv_alloc_sleep : nv_alloc_nosleep)));
 272 #else
 273         return (nvlist_xalloc(nvlp, nvflag, nv_alloc_nosleep));
 274 #endif
 275 }
 276
 277 int
 278 nvlist_xalloc(nvlist_t **nvlp, uint_t nvflag, nv_alloc_t *nva)
 279 {
 280         nvpriv_t *priv;
 281
 282         if (nvlp == NULL || nva == NULL)
 283                 return (EINVAL);
 284
 285         if ((priv = nv_priv_alloc(nva)) == NULL)
 286                 return (ENOMEM);
 287
 288         if ((*nvlp = nv_mem_zalloc(priv,
 289             NV_ALIGN(sizeof (nvlist_t)))) == NULL) {
 290                 nv_mem_free(priv, priv, sizeof (nvpriv_t));
 291                 return (ENOMEM);
 292         }
 293
 294         nvlist_init(*nvlp, nvflag, priv);
 295
 296         return (0);
 297 }
 298
 299 /*
 300  * nvp_buf_alloc - Allocate i_nvp_t for storing a new nv pair.
 301  */
 302 static nvpair_t *
 303 nvp_buf_alloc(nvlist_t *nvl, size_t len)
 304 {
 305         nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv;
 306         i_nvp_t *buf;
 307         nvpair_t *nvp;
 308         size_t nvsize;
 309
 310         /*
 311          * Allocate the buffer
 312          */
 313         nvsize = len + offsetof(i_nvp_t, nvi_nvp);
 314
 315         if ((buf = nv_mem_zalloc(priv, nvsize)) == NULL)
 316                 return (NULL);
 317
 318         nvp = &buf->nvi_nvp;
 319         nvp->nvp_size = len;
 320
 321         return (nvp);
 322 }
 323
 324 /*
 325  * nvp_buf_free - de-Allocate an i_nvp_t.
 326  */
 327 static void
 328 nvp_buf_free(nvlist_t *nvl, nvpair_t *nvp)
 329 {
 330         nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv;
 331         size_t nvsize = nvp->nvp_size + offsetof(i_nvp_t, nvi_nvp);
 332
 333         nv_mem_free(priv, NVPAIR2I_NVP(nvp), nvsize);
 334 }
 335
 336 /*
 337  * nvp_buf_link - link a new nv pair into the nvlist.
 338  */
 339 static void
 340 nvp_buf_link(nvlist_t *nvl, nvpair_t *nvp)
 341 {
 342         nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv;
 343         i_nvp_t *curr = NVPAIR2I_NVP(nvp);
 344
 345         /* Put element at end of nvlist */
 346         if (priv->nvp_list == NULL) {
 347                 priv->nvp_list = priv->nvp_last = curr;
 348         } else {
 349                 curr->nvi_prev = priv->nvp_last;
 350                 priv->nvp_last->nvi_next = curr;
 351                 priv->nvp_last = curr;
 352         }
 353 }
 354
 355 /*
 356  * nvp_buf_unlink - unlink an removed nvpair out of the nvlist.
 357  */
 358 static void
 359 nvp_buf_unlink(nvlist_t *nvl, nvpair_t *nvp)
 360 {
 361         nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv;
 362         i_nvp_t *curr = NVPAIR2I_NVP(nvp);
 363
 364         /*
 365          * protect nvlist_next_nvpair() against walking on freed memory.
 366          */
 367         if (priv->nvp_curr == curr)
 368                 priv->nvp_curr = curr->nvi_next;
 369
 370         if (curr == priv->nvp_list)
 371                 priv->nvp_list = curr->nvi_next;
 372         else
 373                 curr->nvi_prev->nvi_next = curr->nvi_next;
 374
 375         if (curr == priv->nvp_last)
 376                 priv->nvp_last = curr->nvi_prev;
 377         else
 378                 curr->nvi_next->nvi_prev = curr->nvi_prev;
 379 }
 380
 381 /*
 382  * take a nvpair type and number of elements and make sure the are valid
 383  */
 384 static int
 385 i_validate_type_nelem(data_type_t type, uint_t nelem)
 386 {
 387         switch (type) {
 388         case DATA_TYPE_BOOLEAN:
 389                 if (nelem != 0)
 390                         return (EINVAL);
 391                 break;
 392         case DATA_TYPE_BOOLEAN_VALUE:
 393         case DATA_TYPE_BYTE:
 394         case DATA_TYPE_INT8:
 395         case DATA_TYPE_UINT8:
 396         case DATA_TYPE_INT16:
 397         case DATA_TYPE_UINT16:
 398         case DATA_TYPE_INT32:
 399         case DATA_TYPE_UINT32:
 400         case DATA_TYPE_INT64:
 401         case DATA_TYPE_UINT64:
 402         case DATA_TYPE_STRING:
 403         case DATA_TYPE_HRTIME:
 404         case DATA_TYPE_NVLIST:
 405 #if !defined(_KERNEL)
 406         case DATA_TYPE_DOUBLE:
 407 #endif
 408                 if (nelem != 1)
 409                         return (EINVAL);
 410                 break;
 411         case DATA_TYPE_BOOLEAN_ARRAY:
 412         case DATA_TYPE_BYTE_ARRAY:
 413         case DATA_TYPE_INT8_ARRAY:
 414         case DATA_TYPE_UINT8_ARRAY:
 415         case DATA_TYPE_INT16_ARRAY:
 416         case DATA_TYPE_UINT16_ARRAY:
 417         case DATA_TYPE_INT32_ARRAY:
 418         case DATA_TYPE_UINT32_ARRAY:
 419         case DATA_TYPE_INT64_ARRAY:
 420         case DATA_TYPE_UINT64_ARRAY:
 421         case DATA_TYPE_STRING_ARRAY:
 422         case DATA_TYPE_NVLIST_ARRAY:
 423                 /* we allow arrays with 0 elements */
 424                 break;
 425         default:
 426                 return (EINVAL);
 427         }
 428         return (0);
 429 }
 430
 431 /*
 432  * Verify nvp_name_sz and check the name string length.
 433  */
 434 static int
 435 i_validate_nvpair_name(nvpair_t *nvp)
 436 {
 437         if ((nvp->nvp_name_sz <= 0) ||
 438             (nvp->nvp_size < NVP_SIZE_CALC(nvp->nvp_name_sz, 0)))
 439                 return (EFAULT);
 440
 441         /* verify the name string, make sure its terminated */
 442         if (NVP_NAME(nvp)[nvp->nvp_name_sz - 1] != '\0')
 443                 return (EFAULT);
 444
 445         return (strlen(NVP_NAME(nvp)) == nvp->nvp_name_sz - 1 ? 0 : EFAULT);
 446 }
 447
 448 static int
 449 i_validate_nvpair_value(data_type_t type, uint_t nelem, const void *data)
 450 {
 451         switch (type) {
 452         case DATA_TYPE_BOOLEAN_VALUE:
 453                 if (*(boolean_t *)data != B_TRUE &&
 454                     *(boolean_t *)data != B_FALSE)
 455                         return (EINVAL);
 456                 break;
 457         case DATA_TYPE_BOOLEAN_ARRAY: {
 458                 int i;
 459
 460                 for (i = 0; i < nelem; i++)
 461                         if (((boolean_t *)data)[i] != B_TRUE &&
 462                             ((boolean_t *)data)[i] != B_FALSE)
 463                                 return (EINVAL);
 464                 break;
 465         }
 466         default:
 467                 break;
 468         }
 469
 470         return (0);
 471 }
 472
 473 /*
 474  * This function takes a pointer to what should be a nvpair and it's size
 475  * and then verifies that all the nvpair fields make sense and can be
 476  * trusted.  This function is used when decoding packed nvpairs.
 477  */
 478 static int
 479 i_validate_nvpair(nvpair_t *nvp)
 480 {
 481         data_type_t type = NVP_TYPE(nvp);
 482         int size1, size2;
 483
 484         /* verify nvp_name_sz, check the name string length */
 485         if (i_validate_nvpair_name(nvp) != 0)
 486                 return (EFAULT);
 487
 488         if (i_validate_nvpair_value(type, NVP_NELEM(nvp), NVP_VALUE(nvp)) != 0)
 489                 return (EFAULT);
 490
 491         /*
 492          * verify nvp_type, nvp_value_elem, and also possibly
 493          * verify string values and get the value size.
 494          */
 495         size2 = i_get_value_size(type, NVP_VALUE(nvp), NVP_NELEM(nvp));
 496         size1 = nvp->nvp_size - NVP_VALOFF(nvp);
 497         if (size2 < 0 || size1 != NV_ALIGN(size2))
 498                 return (EFAULT);
 499
 500         return (0);
 501 }
 502
 503 static int
 504 nvlist_copy_pairs(nvlist_t *snvl, nvlist_t *dnvl)
 505 {
 506         nvpriv_t *priv;
 507         i_nvp_t *curr;
 508
 509         if ((priv = (nvpriv_t *)(uintptr_t)snvl->nvl_priv) == NULL)
 510                 return (EINVAL);
 511
 512         for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) {
 513                 nvpair_t *nvp = &curr->nvi_nvp;
 514                 int err;
 515
 516                 if ((err = nvlist_add_common(dnvl, NVP_NAME(nvp), NVP_TYPE(nvp),
 517                     NVP_NELEM(nvp), NVP_VALUE(nvp))) != 0)
 518                         return (err);
 519         }
 520
 521         return (0);
 522 }
 523
 524 /*
 525  * Frees all memory allocated for an nvpair (like embedded lists) with
 526  * the exception of the nvpair buffer itself.
 527  */
 528 static void
 529 nvpair_free(nvpair_t *nvp)
 530 {
 531         switch (NVP_TYPE(nvp)) {
 532         case DATA_TYPE_NVLIST:
 533                 nvlist_free(EMBEDDED_NVL(nvp));
 534                 break;
 535         case DATA_TYPE_NVLIST_ARRAY: {
 536                 nvlist_t **nvlp = EMBEDDED_NVL_ARRAY(nvp);
 537                 int i;
 538
 539                 for (i = 0; i < NVP_NELEM(nvp); i++)
 540                         if (nvlp[i] != NULL)
 541                                 nvlist_free(nvlp[i]);
 542                 break;
 543         }
 544         default:
 545                 break;
 546         }
 547 }
 548
 549 /*
 550  * nvlist_free - free an unpacked nvlist
 551  */
 552 void
 553 nvlist_free(nvlist_t *nvl)
 554 {
 555         nvpriv_t *priv;
 556         i_nvp_t *curr;
 557
 558         if (nvl == NULL ||
 559             (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
 560                 return;
 561
 562         /*
 563          * Unpacked nvlist are linked through i_nvp_t
 564          */
 565         curr = priv->nvp_list;
 566         while (curr != NULL) {
 567                 nvpair_t *nvp = &curr->nvi_nvp;
 568                 curr = curr->nvi_next;
 569
 570                 nvpair_free(nvp);
 571                 nvp_buf_free(nvl, nvp);
 572         }
 573
 574         if (!(priv->nvp_stat & NV_STAT_EMBEDDED))
 575                 nv_mem_free(priv, nvl, NV_ALIGN(sizeof (nvlist_t)));
 576         else
 577                 nvl->nvl_priv = 0;
 578
 579         nv_mem_free(priv, priv, sizeof (nvpriv_t));
 580 }
 581
 582 static int
 583 nvlist_contains_nvp(nvlist_t *nvl, nvpair_t *nvp)
 584 {
 585         nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv;
 586         i_nvp_t *curr;
 587
 588         if (nvp == NULL)
 589                 return (0);
 590
 591         for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next)
 592                 if (&curr->nvi_nvp == nvp)
 593                         return (1);
 594
 595         return (0);
 596 }
 597
 598 /*
 599  * Make a copy of nvlist
 600  */
 601 /*ARGSUSED1*/
 602 int
 603 nvlist_dup(nvlist_t *nvl, nvlist_t **nvlp, int kmflag)
 604 {
 605 #if defined(_KERNEL) && !defined(_BOOT)
 606         return (nvlist_xdup(nvl, nvlp,
 607             (kmflag == KM_SLEEP ? nv_alloc_sleep : nv_alloc_nosleep)));
 608 #else
 609         return (nvlist_xdup(nvl, nvlp, nv_alloc_nosleep));
 610 #endif
 611 }
 612
 613 int
 614 nvlist_xdup(nvlist_t *nvl, nvlist_t **nvlp, nv_alloc_t *nva)
 615 {
 616         int err;
 617         nvlist_t *ret;
 618
 619         if (nvl == NULL || nvlp == NULL)
 620                 return (EINVAL);
 621
 622         if ((err = nvlist_xalloc(&ret, nvl->nvl_nvflag, nva)) != 0)
 623                 return (err);
 624
 625         if ((err = nvlist_copy_pairs(nvl, ret)) != 0)
 626                 nvlist_free(ret);
 627         else
 628                 *nvlp = ret;
 629
 630         return (err);
 631 }
 632
 633 /*
 634  * Remove all with matching name
 635  */
 636 int
 637 nvlist_remove_all(nvlist_t *nvl, const char *name)
 638 {
 639         nvpriv_t *priv;
 640         i_nvp_t *curr;
 641         int error = ENOENT;
 642
 643         if (nvl == NULL || name == NULL ||
 644             (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
 645                 return (EINVAL);
 646
 647         curr = priv->nvp_list;
 648         while (curr != NULL) {
 649                 nvpair_t *nvp = &curr->nvi_nvp;
 650
 651                 curr = curr->nvi_next;
 652                 if (strcmp(name, NVP_NAME(nvp)) != 0)
 653                         continue;
 654
 655                 nvp_buf_unlink(nvl, nvp);
 656                 nvpair_free(nvp);
 657                 nvp_buf_free(nvl, nvp);
 658
 659                 error = 0;
 660         }
 661
 662         return (error);
 663 }
 664
 665 /*
 666  * Remove first one with matching name and type
 667  */
 668 int
 669 nvlist_remove(nvlist_t *nvl, const char *name, data_type_t type)
 670 {
 671         nvpriv_t *priv;
 672         i_nvp_t *curr;
 673
 674         if (nvl == NULL || name == NULL ||
 675             (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
 676                 return (EINVAL);
 677
 678         curr = priv->nvp_list;
 679         while (curr != NULL) {
 680                 nvpair_t *nvp = &curr->nvi_nvp;
 681
 682                 if (strcmp(name, NVP_NAME(nvp)) == 0 && NVP_TYPE(nvp) == type) {
 683                         nvp_buf_unlink(nvl, nvp);
 684                         nvpair_free(nvp);
 685                         nvp_buf_free(nvl, nvp);
 686
 687                         return (0);
 688                 }
 689                 curr = curr->nvi_next;
 690         }
 691
 692         return (ENOENT);
 693 }
 694
 695 /*
 696  * This function calculates the size of an nvpair value.
 697  *
 698  * The data argument controls the behavior in case of the data types
 699  *      DATA_TYPE_STRING        and
 700  *      DATA_TYPE_STRING_ARRAY
 701  * Is data == NULL then the size of the string(s) is excluded.
 702  */
 703 static int
 704 i_get_value_size(data_type_t type, const void *data, uint_t nelem)
 705 {
 706         uint64_t value_sz;
 707
 708         if (i_validate_type_nelem(type, nelem) != 0)
 709                 return (-1);
 710
 711         /* Calculate required size for holding value */
 712         switch (type) {
 713         case DATA_TYPE_BOOLEAN:
 714                 value_sz = 0;
 715                 break;
 716         case DATA_TYPE_BOOLEAN_VALUE:
 717                 value_sz = sizeof (boolean_t);
 718                 break;
 719         case DATA_TYPE_BYTE:
 720                 value_sz = sizeof (uchar_t);
 721                 break;
 722         case DATA_TYPE_INT8:
 723                 value_sz = sizeof (int8_t);
 724                 break;
 725         case DATA_TYPE_UINT8:
 726                 value_sz = sizeof (uint8_t);
 727                 break;
 728         case DATA_TYPE_INT16:
 729                 value_sz = sizeof (int16_t);
 730                 break;
 731         case DATA_TYPE_UINT16:
 732                 value_sz = sizeof (uint16_t);
 733                 break;
 734         case DATA_TYPE_INT32:
 735                 value_sz = sizeof (int32_t);
 736                 break;
 737         case DATA_TYPE_UINT32:
 738                 value_sz = sizeof (uint32_t);
 739                 break;
 740         case DATA_TYPE_INT64:
 741                 value_sz = sizeof (int64_t);
 742                 break;
 743         case DATA_TYPE_UINT64:
 744                 value_sz = sizeof (uint64_t);
 745                 break;
 746 #if !defined(_KERNEL)
 747         case DATA_TYPE_DOUBLE:
 748                 value_sz = sizeof (double);
 749                 break;
 750 #endif
 751         case DATA_TYPE_STRING:
 752                 if (data == NULL)
 753                         value_sz = 0;
 754                 else
 755                         value_sz = strlen(data) + 1;
 756                 break;
 757         case DATA_TYPE_BOOLEAN_ARRAY:
 758                 value_sz = (uint64_t)nelem * sizeof (boolean_t);
 759                 break;
 760         case DATA_TYPE_BYTE_ARRAY:
 761                 value_sz = (uint64_t)nelem * sizeof (uchar_t);
 762                 break;
 763         case DATA_TYPE_INT8_ARRAY:
 764                 value_sz = (uint64_t)nelem * sizeof (int8_t);
 765                 break;
 766         case DATA_TYPE_UINT8_ARRAY:
 767                 value_sz = (uint64_t)nelem * sizeof (uint8_t);
 768                 break;
 769         case DATA_TYPE_INT16_ARRAY:
 770                 value_sz = (uint64_t)nelem * sizeof (int16_t);
 771                 break;
 772         case DATA_TYPE_UINT16_ARRAY:
 773                 value_sz = (uint64_t)nelem * sizeof (uint16_t);
 774                 break;
 775         case DATA_TYPE_INT32_ARRAY:
 776                 value_sz = (uint64_t)nelem * sizeof (int32_t);
 777                 break;
 778         case DATA_TYPE_UINT32_ARRAY:
 779                 value_sz = (uint64_t)nelem * sizeof (uint32_t);
 780                 break;
 781         case DATA_TYPE_INT64_ARRAY:
 782                 value_sz = (uint64_t)nelem * sizeof (int64_t);
 783                 break;
 784         case DATA_TYPE_UINT64_ARRAY:
 785                 value_sz = (uint64_t)nelem * sizeof (uint64_t);
 786                 break;
 787         case DATA_TYPE_STRING_ARRAY:
 788                 value_sz = (uint64_t)nelem * sizeof (uint64_t);
 789
 790                 if (data != NULL) {
 791                         char *const *strs = data;
 792                         uint_t i;
 793
 794                         /* no alignment requirement for strings */
 795                         for (i = 0; i < nelem; i++) {
 796                                 if (strs[i] == NULL)
 797                                         return (-1);
 798                                 value_sz += strlen(strs[i]) + 1;
 799                         }
 800                 }
 801                 break;
 802         case DATA_TYPE_HRTIME:
 803                 value_sz = sizeof (hrtime_t);
 804                 break;
 805         case DATA_TYPE_NVLIST:
 806                 value_sz = NV_ALIGN(sizeof (nvlist_t));
 807                 break;
 808         case DATA_TYPE_NVLIST_ARRAY:
 809                 value_sz = (uint64_t)nelem * sizeof (uint64_t) +
 810                     (uint64_t)nelem * NV_ALIGN(sizeof (nvlist_t));
 811                 break;
 812         default:
 813                 return (-1);
 814         }
 815
 816         return (value_sz > INT32_MAX ? -1 : (int)value_sz);
 817 }
 818
 819 static int
 820 nvlist_copy_embedded(nvlist_t *nvl, nvlist_t *onvl, nvlist_t *emb_nvl)
 821 {
 822         nvpriv_t *priv;
 823         int err;
 824
 825         if ((priv = nv_priv_alloc_embedded((nvpriv_t *)(uintptr_t)
 826             nvl->nvl_priv)) == NULL)
 827                 return (ENOMEM);
 828
 829         nvlist_init(emb_nvl, onvl->nvl_nvflag, priv);
 830
 831         if ((err = nvlist_copy_pairs(onvl, emb_nvl)) != 0) {
 832                 nvlist_free(emb_nvl);
 833                 emb_nvl->nvl_priv = 0;
 834         }
 835
 836         return (err);
 837 }
 838
 839 /*
 840  * nvlist_add_common - Add new <name,value> pair to nvlist
 841  */
 842 static int
 843 nvlist_add_common(nvlist_t *nvl, const char *name,
 844     data_type_t type, uint_t nelem, const void *data)
 845 {
 846         nvpair_t *nvp;
 847         uint_t i;
 848
 849         int nvp_sz, name_sz, value_sz;
 850         int err = 0;
 851
 852         if (name == NULL || nvl == NULL || nvl->nvl_priv == 0)
 853                 return (EINVAL);
 854
 855         if (nelem != 0 && data == NULL)
 856                 return (EINVAL);
 857
 858         /*
 859          * Verify type and nelem and get the value size.
 860          * In case of data types DATA_TYPE_STRING and DATA_TYPE_STRING_ARRAY
 861          * is the size of the string(s) included.
 862          */
 863         if ((value_sz = i_get_value_size(type, data, nelem)) < 0)
 864                 return (EINVAL);
 865
 866         if (i_validate_nvpair_value(type, nelem, data) != 0)
 867                 return (EINVAL);
 868
 869         /*
 870          * If we're adding an nvlist or nvlist array, ensure that we are not
 871          * adding the input nvlist to itself, which would cause recursion,
 872          * and ensure that no NULL nvlist pointers are present.
 873          */
 874         switch (type) {
 875         case DATA_TYPE_NVLIST:
 876                 if (data == nvl || data == NULL)
 877                         return (EINVAL);
 878                 break;
 879         case DATA_TYPE_NVLIST_ARRAY: {
 880                 nvlist_t **onvlp = (nvlist_t **)data;
 881                 for (i = 0; i < nelem; i++) {
 882                         if (onvlp[i] == nvl || onvlp[i] == NULL)
 883                                 return (EINVAL);
 884                 }
 885                 break;
 886         }
 887         default:
 888                 break;
 889         }
 890
 891         /* calculate sizes of the nvpair elements and the nvpair itself */
 892         name_sz = strlen(name) + 1;
 893
 894         nvp_sz = NVP_SIZE_CALC(name_sz, value_sz);
 895
 896         if ((nvp = nvp_buf_alloc(nvl, nvp_sz)) == NULL)
 897                 return (ENOMEM);
 898
 899         ASSERT(nvp->nvp_size == nvp_sz);
 900         nvp->nvp_name_sz = name_sz;
 901         nvp->nvp_value_elem = nelem;
 902         nvp->nvp_type = type;
 903         bcopy(name, NVP_NAME(nvp), name_sz);
 904
 905         switch (type) {
 906         case DATA_TYPE_BOOLEAN:
 907                 break;
 908         case DATA_TYPE_STRING_ARRAY: {
 909                 char *const *strs = data;
 910                 char *buf = NVP_VALUE(nvp);
 911                 char **cstrs = (void *)buf;
 912
 913                 /* skip pre-allocated space for pointer array */
 914                 buf += nelem * sizeof (uint64_t);
 915                 for (i = 0; i < nelem; i++) {
 916                         int slen = strlen(strs[i]) + 1;
 917                         bcopy(strs[i], buf, slen);
 918                         cstrs[i] = buf;
 919                         buf += slen;
 920                 }
 921                 break;
 922         }
 923         case DATA_TYPE_NVLIST: {
 924                 nvlist_t *nnvl = EMBEDDED_NVL(nvp);
 925                 nvlist_t *onvl = (nvlist_t *)data;
 926
 927                 if ((err = nvlist_copy_embedded(nvl, onvl, nnvl)) != 0) {
 928                         nvp_buf_free(nvl, nvp);
 929                         return (err);
 930                 }
 931                 break;
 932         }
 933         case DATA_TYPE_NVLIST_ARRAY: {
 934                 nvlist_t **onvlp = (nvlist_t **)data;
 935                 nvlist_t **nvlp = EMBEDDED_NVL_ARRAY(nvp);
 936                 nvlist_t *embedded = (nvlist_t *)
 937                     ((uintptr_t)nvlp + nelem * sizeof (uint64_t));
 938
 939                 for (i = 0; i < nelem; i++) {
 940                         if ((err = nvlist_copy_embedded(nvl,
 941                             onvlp[i], embedded)) != 0) {
 942                                 /*
 943                                  * Free any successfully created lists
 944                                  */
 945                                 nvpair_free(nvp);
 946                                 nvp_buf_free(nvl, nvp);
 947                                 return (err);
 948                         }
 949
 950                         nvlp[i] = embedded++;
 951                 }
 952                 break;
 953         }
 954         default:
 955                 bcopy(data, NVP_VALUE(nvp), value_sz);
 956         }
 957
 958         /* if unique name, remove before add */
 959         if (nvl->nvl_nvflag & NV_UNIQUE_NAME)
 960                 (void) nvlist_remove_all(nvl, name);
 961         else if (nvl->nvl_nvflag & NV_UNIQUE_NAME_TYPE)
 962                 (void) nvlist_remove(nvl, name, type);
 963
 964         nvp_buf_link(nvl, nvp);
 965
 966         return (0);
 967 }
 968
 969 int
 970 nvlist_add_boolean(nvlist_t *nvl, const char *name)
 971 {
 972         return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN, 0, NULL));
 973 }
 974
 975 int
 976 nvlist_add_boolean_value(nvlist_t *nvl, const char *name, boolean_t val)
 977 {
 978         return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN_VALUE, 1, &val));
 979 }
 980
 981 int
 982 nvlist_add_byte(nvlist_t *nvl, const char *name, uchar_t val)
 983 {
 984         return (nvlist_add_common(nvl, name, DATA_TYPE_BYTE, 1, &val));
 985 }
 986
 987 int
 988 nvlist_add_int8(nvlist_t *nvl, const char *name, int8_t val)
 989 {
 990         return (nvlist_add_common(nvl, name, DATA_TYPE_INT8, 1, &val));
 991 }
 992
 993 int
 994 nvlist_add_uint8(nvlist_t *nvl, const char *name, uint8_t val)
 995 {
 996         return (nvlist_add_common(nvl, name, DATA_TYPE_UINT8, 1, &val));
 997 }
 998
 999 int
1000 nvlist_add_int16(nvlist_t *nvl, const char *name, int16_t val)
1001 {
1002         return (nvlist_add_common(nvl, name, DATA_TYPE_INT16, 1, &val));
1003 }
1004
1005 int
1006 nvlist_add_uint16(nvlist_t *nvl, const char *name, uint16_t val)
1007 {
1008         return (nvlist_add_common(nvl, name, DATA_TYPE_UINT16, 1, &val));
1009 }
1010
1011 int
1012 nvlist_add_int32(nvlist_t *nvl, const char *name, int32_t val)
1013 {
1014         return (nvlist_add_common(nvl, name, DATA_TYPE_INT32, 1, &val));
1015 }
1016
1017 int
1018 nvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val)
1019 {
1020         return (nvlist_add_common(nvl, name, DATA_TYPE_UINT32, 1, &val));
1021 }
1022
1023 int
1024 nvlist_add_int64(nvlist_t *nvl, const char *name, int64_t val)
1025 {
1026         return (nvlist_add_common(nvl, name, DATA_TYPE_INT64, 1, &val));
1027 }
1028
1029 int
1030 nvlist_add_uint64(nvlist_t *nvl, const char *name, uint64_t val)
1031 {
1032         return (nvlist_add_common(nvl, name, DATA_TYPE_UINT64, 1, &val));
1033 }
1034
1035 #if !defined(_KERNEL)
1036 int
1037 nvlist_add_double(nvlist_t *nvl, const char *name, double val)
1038 {
1039         return (nvlist_add_common(nvl, name, DATA_TYPE_DOUBLE, 1, &val));
1040 }
1041 #endif
1042
1043 int
1044 nvlist_add_string(nvlist_t *nvl, const char *name, const char *val)
1045 {
1046         return (nvlist_add_common(nvl, name, DATA_TYPE_STRING, 1, (void *)val));
1047 }
1048
1049 int
1050 nvlist_add_boolean_array(nvlist_t *nvl, const char *name,
1051     boolean_t *a, uint_t n)
1052 {
1053         return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN_ARRAY, n, a));
1054 }
1055
1056 int
1057 nvlist_add_byte_array(nvlist_t *nvl, const char *name, uchar_t *a, uint_t n)
1058 {
1059         return (nvlist_add_common(nvl, name, DATA_TYPE_BYTE_ARRAY, n, a));
1060 }
1061
1062 int
1063 nvlist_add_int8_array(nvlist_t *nvl, const char *name, int8_t *a, uint_t n)
1064 {
1065         return (nvlist_add_common(nvl, name, DATA_TYPE_INT8_ARRAY, n, a));
1066 }
1067
1068 int
1069 nvlist_add_uint8_array(nvlist_t *nvl, const char *name, uint8_t *a, uint_t n)
1070 {
1071         return (nvlist_add_common(nvl, name, DATA_TYPE_UINT8_ARRAY, n, a));
1072 }
1073
1074 int
1075 nvlist_add_int16_array(nvlist_t *nvl, const char *name, int16_t *a, uint_t n)
1076 {
1077         return (nvlist_add_common(nvl, name, DATA_TYPE_INT16_ARRAY, n, a));
1078 }
1079
1080 int
1081 nvlist_add_uint16_array(nvlist_t *nvl, const char *name, uint16_t *a, uint_t n)
1082 {
1083         return (nvlist_add_common(nvl, name, DATA_TYPE_UINT16_ARRAY, n, a));
1084 }
1085
1086 int
1087 nvlist_add_int32_array(nvlist_t *nvl, const char *name, int32_t *a, uint_t n)
1088 {
1089         return (nvlist_add_common(nvl, name, DATA_TYPE_INT32_ARRAY, n, a));
1090 }
1091
1092 int
1093 nvlist_add_uint32_array(nvlist_t *nvl, const char *name, uint32_t *a, uint_t n)
1094 {
1095         return (nvlist_add_common(nvl, name, DATA_TYPE_UINT32_ARRAY, n, a));
1096 }
1097
1098 int
1099 nvlist_add_int64_array(nvlist_t *nvl, const char *name, int64_t *a, uint_t n)
1100 {
1101         return (nvlist_add_common(nvl, name, DATA_TYPE_INT64_ARRAY, n, a));
1102 }
1103
1104 int
1105 nvlist_add_uint64_array(nvlist_t *nvl, const char *name, uint64_t *a, uint_t n)
1106 {
1107         return (nvlist_add_common(nvl, name, DATA_TYPE_UINT64_ARRAY, n, a));
1108 }
1109
1110 int
1111 nvlist_add_string_array(nvlist_t *nvl, const char *name,
1112     char *const *a, uint_t n)
1113 {
1114         return (nvlist_add_common(nvl, name, DATA_TYPE_STRING_ARRAY, n, a));
1115 }
1116
1117 int
1118 nvlist_add_hrtime(nvlist_t *nvl, const char *name, hrtime_t val)
1119 {
1120         return (nvlist_add_common(nvl, name, DATA_TYPE_HRTIME, 1, &val));
1121 }
1122
1123 int
1124 nvlist_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val)
1125 {
1126         return (nvlist_add_common(nvl, name, DATA_TYPE_NVLIST, 1, val));
1127 }
1128
1129 int
1130 nvlist_add_nvlist_array(nvlist_t *nvl, const char *name, nvlist_t **a, uint_t n)
1131 {
1132         return (nvlist_add_common(nvl, name, DATA_TYPE_NVLIST_ARRAY, n, a));
1133 }
1134
1135 /* reading name-value pairs */
1136 nvpair_t *
1137 nvlist_next_nvpair(nvlist_t *nvl, nvpair_t *nvp)
1138 {
1139         nvpriv_t *priv;
1140         i_nvp_t *curr;
1141
1142         if (nvl == NULL ||
1143             (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
1144                 return (NULL);
1145
1146         curr = NVPAIR2I_NVP(nvp);
1147
1148         /*
1149          * Ensure that nvp is a valid nvpair on this nvlist.
1150          * NB: nvp_curr is used only as a hint so that we don't always
1151          * have to walk the list to determine if nvp is still on the list.
1152          */
1153         if (nvp == NULL)
1154                 curr = priv->nvp_list;
1155         else if (priv->nvp_curr == curr || nvlist_contains_nvp(nvl, nvp))
1156                 curr = curr->nvi_next;
1157         else
1158                 curr = NULL;
1159
1160         priv->nvp_curr = curr;
1161
1162         return (curr != NULL ? &curr->nvi_nvp : NULL);
1163 }
1164
1165 char *
1166 nvpair_name(nvpair_t *nvp)
1167 {
1168         return (NVP_NAME(nvp));
1169 }
1170
1171 data_type_t
1172 nvpair_type(nvpair_t *nvp)
1173 {
1174         return (NVP_TYPE(nvp));
1175 }
1176
1177 int
1178 nvpair_type_is_array(nvpair_t *nvp)
1179 {
1180         data_type_t type = NVP_TYPE(nvp);
1181
1182         if ((type == DATA_TYPE_BYTE_ARRAY) ||
1183             (type == DATA_TYPE_UINT8_ARRAY) ||
1184             (type == DATA_TYPE_INT16_ARRAY) ||
1185             (type == DATA_TYPE_UINT16_ARRAY) ||
1186             (type == DATA_TYPE_INT32_ARRAY) ||
1187             (type == DATA_TYPE_UINT32_ARRAY) ||
1188             (type == DATA_TYPE_INT64_ARRAY) ||
1189             (type == DATA_TYPE_UINT64_ARRAY) ||
1190             (type == DATA_TYPE_BOOLEAN_ARRAY) ||
1191             (type == DATA_TYPE_STRING_ARRAY) ||
1192             (type == DATA_TYPE_NVLIST_ARRAY))
1193                 return (1);
1194         return (0);
1195
1196 }
1197
1198 static int
1199 nvpair_value_common(nvpair_t *nvp, data_type_t type, uint_t *nelem, void *data)
1200 {
1201         if (nvp == NULL || nvpair_type(nvp) != type)
1202                 return (EINVAL);
1203
1204         /*
1205          * For non-array types, we copy the data.
1206          * For array types (including string), we set a pointer.
1207          */
1208         switch (type) {
1209         case DATA_TYPE_BOOLEAN:
1210                 if (nelem != NULL)
1211                         *nelem = 0;
1212                 break;
1213
1214         case DATA_TYPE_BOOLEAN_VALUE:
1215         case DATA_TYPE_BYTE:
1216         case DATA_TYPE_INT8:
1217         case DATA_TYPE_UINT8:
1218         case DATA_TYPE_INT16:
1219         case DATA_TYPE_UINT16:
1220         case DATA_TYPE_INT32:
1221         case DATA_TYPE_UINT32:
1222         case DATA_TYPE_INT64:
1223         case DATA_TYPE_UINT64:
1224         case DATA_TYPE_HRTIME:
1225 #if !defined(_KERNEL)
1226         case DATA_TYPE_DOUBLE:
1227 #endif
1228                 if (data == NULL)
1229                         return (EINVAL);
1230                 bcopy(NVP_VALUE(nvp), data,
1231                     (size_t)i_get_value_size(type, NULL, 1));
1232                 if (nelem != NULL)
1233                         *nelem = 1;
1234                 break;
1235
1236         case DATA_TYPE_NVLIST:
1237         case DATA_TYPE_STRING:
1238                 if (data == NULL)
1239                         return (EINVAL);
1240                 *(void **)data = (void *)NVP_VALUE(nvp);
1241                 if (nelem != NULL)
1242                         *nelem = 1;
1243                 break;
1244
1245         case DATA_TYPE_BOOLEAN_ARRAY:
1246         case DATA_TYPE_BYTE_ARRAY:
1247         case DATA_TYPE_INT8_ARRAY:
1248         case DATA_TYPE_UINT8_ARRAY:
1249         case DATA_TYPE_INT16_ARRAY:
1250         case DATA_TYPE_UINT16_ARRAY:
1251         case DATA_TYPE_INT32_ARRAY:
1252         case DATA_TYPE_UINT32_ARRAY:
1253         case DATA_TYPE_INT64_ARRAY:
1254         case DATA_TYPE_UINT64_ARRAY:
1255         case DATA_TYPE_STRING_ARRAY:
1256         case DATA_TYPE_NVLIST_ARRAY:
1257                 if (nelem == NULL || data == NULL)
1258                         return (EINVAL);
1259                 if ((*nelem = NVP_NELEM(nvp)) != 0)
1260                         *(void **)data = (void *)NVP_VALUE(nvp);
1261                 else
1262                         *(void **)data = NULL;
1263                 break;
1264
1265         default:
1266                 return (ENOTSUP);
1267         }
1268
1269         return (0);
1270 }
1271
1272 static int
1273 nvlist_lookup_common(nvlist_t *nvl, const char *name, data_type_t type,
1274     uint_t *nelem, void *data)
1275 {
1276         nvpriv_t *priv;
1277         nvpair_t *nvp;
1278         i_nvp_t *curr;
1279
1280         if (name == NULL || nvl == NULL ||
1281             (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
1282                 return (EINVAL);
1283
1284         if (!(nvl->nvl_nvflag & (NV_UNIQUE_NAME | NV_UNIQUE_NAME_TYPE)))
1285                 return (ENOTSUP);
1286
1287         for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) {
1288                 nvp = &curr->nvi_nvp;
1289
1290                 if (strcmp(name, NVP_NAME(nvp)) == 0 && NVP_TYPE(nvp) == type)
1291                         return (nvpair_value_common(nvp, type, nelem, data));
1292         }
1293
1294         return (ENOENT);
1295 }
1296
1297 int
1298 nvlist_lookup_boolean(nvlist_t *nvl, const char *name)
1299 {
1300         return (nvlist_lookup_common(nvl, name, DATA_TYPE_BOOLEAN, NULL, NULL));
1301 }
1302
1303 int
1304 nvlist_lookup_boolean_value(nvlist_t *nvl, const char *name, boolean_t *val)
1305 {
1306         return (nvlist_lookup_common(nvl, name,
1307             DATA_TYPE_BOOLEAN_VALUE, NULL, val));
1308 }
1309
1310 int
1311 nvlist_lookup_byte(nvlist_t *nvl, const char *name, uchar_t *val)
1312 {
1313         return (nvlist_lookup_common(nvl, name, DATA_TYPE_BYTE, NULL, val));
1314 }
1315
1316 int
1317 nvlist_lookup_int8(nvlist_t *nvl, const char *name, int8_t *val)
1318 {
1319         return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT8, NULL, val));
1320 }
1321
1322 int
1323 nvlist_lookup_uint8(nvlist_t *nvl, const char *name, uint8_t *val)
1324 {
1325         return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT8, NULL, val));
1326 }
1327
1328 int
1329 nvlist_lookup_int16(nvlist_t *nvl, const char *name, int16_t *val)
1330 {
1331         return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT16, NULL, val));
1332 }
1333
1334 int
1335 nvlist_lookup_uint16(nvlist_t *nvl, const char *name, uint16_t *val)
1336 {
1337         return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT16, NULL, val));
1338 }
1339
1340 int
1341 nvlist_lookup_int32(nvlist_t *nvl, const char *name, int32_t *val)
1342 {
1343         return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT32, NULL, val));
1344 }
1345
1346 int
1347 nvlist_lookup_uint32(nvlist_t *nvl, const char *name, uint32_t *val)
1348 {
1349         return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT32, NULL, val));
1350 }
1351
1352 int
1353 nvlist_lookup_int64(nvlist_t *nvl, const char *name, int64_t *val)
1354 {
1355         return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT64, NULL, val));
1356 }
1357
1358 int
1359 nvlist_lookup_uint64(nvlist_t *nvl, const char *name, uint64_t *val)
1360 {
1361         return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT64, NULL, val));
1362 }
1363
1364 #if !defined(_KERNEL)
1365 int
1366 nvlist_lookup_double(nvlist_t *nvl, const char *name, double *val)
1367 {
1368         return (nvlist_lookup_common(nvl, name, DATA_TYPE_DOUBLE, NULL, val));
1369 }
1370 #endif
1371
1372 int
1373 nvlist_lookup_string(nvlist_t *nvl, const char *name, char **val)
1374 {
1375         return (nvlist_lookup_common(nvl, name, DATA_TYPE_STRING, NULL, val));
1376 }
1377
1378 int
1379 nvlist_lookup_nvlist(nvlist_t *nvl, const char *name, nvlist_t **val)
1380 {
1381         return (nvlist_lookup_common(nvl, name, DATA_TYPE_NVLIST, NULL, val));
1382 }
1383
1384 int
1385 nvlist_lookup_boolean_array(nvlist_t *nvl, const char *name,
1386     boolean_t **a, uint_t *n)
1387 {
1388         return (nvlist_lookup_common(nvl, name,
1389             DATA_TYPE_BOOLEAN_ARRAY, n, a));
1390 }
1391
1392 int
1393 nvlist_lookup_byte_array(nvlist_t *nvl, const char *name,
1394     uchar_t **a, uint_t *n)
1395 {
1396         return (nvlist_lookup_common(nvl, name, DATA_TYPE_BYTE_ARRAY, n, a));
1397 }
1398
1399 int
1400 nvlist_lookup_int8_array(nvlist_t *nvl, const char *name, int8_t **a, uint_t *n)
1401 {
1402         return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT8_ARRAY, n, a));
1403 }
1404
1405 int
1406 nvlist_lookup_uint8_array(nvlist_t *nvl, const char *name,
1407     uint8_t **a, uint_t *n)
1408 {
1409         return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT8_ARRAY, n, a));
1410 }
1411
1412 int
1413 nvlist_lookup_int16_array(nvlist_t *nvl, const char *name,
1414     int16_t **a, uint_t *n)
1415 {
1416         return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT16_ARRAY, n, a));
1417 }
1418
1419 int
1420 nvlist_lookup_uint16_array(nvlist_t *nvl, const char *name,
1421     uint16_t **a, uint_t *n)
1422 {
1423         return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT16_ARRAY, n, a));
1424 }
1425
1426 int
1427 nvlist_lookup_int32_array(nvlist_t *nvl, const char *name,
1428     int32_t **a, uint_t *n)
1429 {
1430         return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT32_ARRAY, n, a));
1431 }
1432
1433 int
1434 nvlist_lookup_uint32_array(nvlist_t *nvl, const char *name,
1435     uint32_t **a, uint_t *n)
1436 {
1437         return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT32_ARRAY, n, a));
1438 }
1439
1440 int
1441 nvlist_lookup_int64_array(nvlist_t *nvl, const char *name,
1442     int64_t **a, uint_t *n)
1443 {
1444         return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT64_ARRAY, n, a));
1445 }
1446
1447 int
1448 nvlist_lookup_uint64_array(nvlist_t *nvl, const char *name,
1449     uint64_t **a, uint_t *n)
1450 {
1451         return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT64_ARRAY, n, a));
1452 }
1453
1454 int
1455 nvlist_lookup_string_array(nvlist_t *nvl, const char *name,
1456     char ***a, uint_t *n)
1457 {
1458         return (nvlist_lookup_common(nvl, name, DATA_TYPE_STRING_ARRAY, n, a));
1459 }
1460
1461 int
1462 nvlist_lookup_nvlist_array(nvlist_t *nvl, const char *name,
1463     nvlist_t ***a, uint_t *n)
1464 {
1465         return (nvlist_lookup_common(nvl, name, DATA_TYPE_NVLIST_ARRAY, n, a));
1466 }
1467
1468 int
1469 nvlist_lookup_hrtime(nvlist_t *nvl, const char *name, hrtime_t *val)
1470 {
1471         return (nvlist_lookup_common(nvl, name, DATA_TYPE_HRTIME, NULL, val));
1472 }
1473
1474 int
1475 nvlist_lookup_pairs(nvlist_t *nvl, int flag, ...)
1476 {
1477         va_list ap;
1478         char *name;
1479         int noentok = (flag & NV_FLAG_NOENTOK ? 1 : 0);
1480         int ret = 0;
1481
1482         va_start(ap, flag);
1483         while (ret == 0 && (name = va_arg(ap, char *)) != NULL) {
1484                 data_type_t type;
1485                 void *val;
1486                 uint_t *nelem;
1487
1488                 switch (type = va_arg(ap, data_type_t)) {
1489                 case DATA_TYPE_BOOLEAN:
1490                         ret = nvlist_lookup_common(nvl, name, type, NULL, NULL);
1491                         break;
1492
1493                 case DATA_TYPE_BOOLEAN_VALUE:
1494                 case DATA_TYPE_BYTE:
1495                 case DATA_TYPE_INT8:
1496                 case DATA_TYPE_UINT8:
1497                 case DATA_TYPE_INT16:
1498                 case DATA_TYPE_UINT16:
1499                 case DATA_TYPE_INT32:
1500                 case DATA_TYPE_UINT32:
1501                 case DATA_TYPE_INT64:
1502                 case DATA_TYPE_UINT64:
1503                 case DATA_TYPE_HRTIME:
1504                 case DATA_TYPE_STRING:
1505                 case DATA_TYPE_NVLIST:
1506 #if !defined(_KERNEL)
1507                 case DATA_TYPE_DOUBLE:
1508 #endif
1509                         val = va_arg(ap, void *);
1510                         ret = nvlist_lookup_common(nvl, name, type, NULL, val);
1511                         break;
1512
1513                 case DATA_TYPE_BYTE_ARRAY:
1514                 case DATA_TYPE_BOOLEAN_ARRAY:
1515                 case DATA_TYPE_INT8_ARRAY:
1516                 case DATA_TYPE_UINT8_ARRAY:
1517                 case DATA_TYPE_INT16_ARRAY:
1518                 case DATA_TYPE_UINT16_ARRAY:
1519                 case DATA_TYPE_INT32_ARRAY:
1520                 case DATA_TYPE_UINT32_ARRAY:
1521                 case DATA_TYPE_INT64_ARRAY:
1522                 case DATA_TYPE_UINT64_ARRAY:
1523                 case DATA_TYPE_STRING_ARRAY:
1524                 case DATA_TYPE_NVLIST_ARRAY:
1525                         val = va_arg(ap, void *);
1526                         nelem = va_arg(ap, uint_t *);
1527                         ret = nvlist_lookup_common(nvl, name, type, nelem, val);
1528                         break;
1529
1530                 default:
1531                         ret = EINVAL;
1532                 }
1533
1534                 if (ret == ENOENT && noentok)
1535                         ret = 0;
1536         }
1537         va_end(ap);
1538
1539         return (ret);
1540 }
1541
1542 /*
1543  * Find the 'name'ed nvpair in the nvlist 'nvl'. If 'name' found, the function
1544  * returns zero and a pointer to the matching nvpair is returned in '*ret'
1545  * (given 'ret' is non-NULL). If 'sep' is specified then 'name' will penitrate
1546  * multiple levels of embedded nvlists, with 'sep' as the separator. As an
1547  * example, if sep is '.', name might look like: "a" or "a.b" or "a.c[3]" or
1548  * "a.d[3].e[1]".  This matches the C syntax for array embed (for convience,
1549  * code also supports "a.d[3]e[1]" syntax).
1550  *
1551  * If 'ip' is non-NULL and the last name component is an array, return the
1552  * value of the "...[index]" array index in *ip. For an array reference that
1553  * is not indexed, *ip will be returned as -1. If there is a syntax error in
1554  * 'name', and 'ep' is non-NULL then *ep will be set to point to the location
1555  * inside the 'name' string where the syntax error was detected.
1556  */
1557 static int
1558 nvlist_lookup_nvpair_ei_sep(nvlist_t *nvl, const char *name, const char sep,
1559     nvpair_t **ret, int *ip, char **ep)
1560 {
1561         nvpair_t        *nvp;
1562         const char      *np;
1563         char            *sepp;
1564         char            *idxp, *idxep;
1565         nvlist_t        **nva;
1566         long            idx;
1567         int             n;
1568
1569         if (ip)
1570                 *ip = -1;                       /* not indexed */
1571         if (ep)
1572                 *ep = NULL;
1573
1574         if ((nvl == NULL) || (name == NULL))
1575                 return (EINVAL);
1576
1577         /* step through components of name */
1578         for (np = name; np && *np; np = sepp) {
1579                 /* ensure unique names */
1580                 if (!(nvl->nvl_nvflag & NV_UNIQUE_NAME))
1581                         return (ENOTSUP);
1582
1583                 /* skip white space */
1584                 skip_whitespace(np);
1585                 if (*np == 0)
1586                         break;
1587
1588                 /* set 'sepp' to end of current component 'np' */
1589                 if (sep)
1590                         sepp = strchr(np, sep);
1591                 else
1592                         sepp = NULL;
1593
1594                 /* find start of next "[ index ]..." */
1595                 idxp = strchr(np, '[');
1596
1597                 /* if sepp comes first, set idxp to NULL */
1598                 if (sepp && idxp && (sepp < idxp))
1599                         idxp = NULL;
1600
1601                 /*
1602                  * At this point 'idxp' is set if there is an index
1603                  * expected for the current component.
1604                  */
1605                 if (idxp) {
1606                         /* set 'n' to length of current 'np' name component */
1607                         n = idxp++ - np;
1608
1609                         /* keep sepp up to date for *ep use as we advance */
1610                         skip_whitespace(idxp);
1611                         sepp = idxp;
1612
1613                         /* determine the index value */
1614 #if defined(_KERNEL) && !defined(_BOOT)
1615                         if (ddi_strtol(idxp, &idxep, 0, &idx))
1616                                 goto fail;
1617 #else
1618                         idx = strtol(idxp, &idxep, 0);
1619 #endif
1620                         if (idxep == idxp)
1621                                 goto fail;
1622
1623                         /* keep sepp up to date for *ep use as we advance */
1624                         sepp = idxep;
1625
1626                         /* skip white space index value and check for ']' */
1627                         skip_whitespace(sepp);
1628                         if (*sepp++ != ']')
1629                                 goto fail;
1630
1631                         /* for embedded arrays, support C syntax: "a[1].b" */
1632                         skip_whitespace(sepp);
1633                         if (sep && (*sepp == sep))
1634                                 sepp++;
1635                 } else if (sepp) {
1636                         n = sepp++ - np;
1637                 } else {
1638                         n = strlen(np);
1639                 }
1640
1641                 /* trim trailing whitespace by reducing length of 'np' */
1642                 if (n == 0)
1643                         goto fail;
1644                 for (n--; (np[n] == ' ') || (np[n] == '\t'); n--)
1645                         ;
1646                 n++;
1647
1648                 /* skip whitespace, and set sepp to NULL if complete */
1649                 if (sepp) {
1650                         skip_whitespace(sepp);
1651                         if (*sepp == 0)
1652                                 sepp = NULL;
1653                 }
1654
1655                 /*
1656                  * At this point:
1657                  * o  'n' is the length of current 'np' component.
1658                  * o  'idxp' is set if there was an index, and value 'idx'.
1659                  * o  'sepp' is set to the beginning of the next component,
1660                  *    and set to NULL if we have no more components.
1661                  *
1662                  * Search for nvpair with matching component name.
1663                  */
1664                 for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL;
1665                     nvp = nvlist_next_nvpair(nvl, nvp)) {
1666
1667                         /* continue if no match on name */
1668                         if (strncmp(np, nvpair_name(nvp), n) ||
1669                             (strlen(nvpair_name(nvp)) != n))
1670                                 continue;
1671
1672                         /* if indexed, verify type is array oriented */
1673                         if (idxp && !nvpair_type_is_array(nvp))
1674                                 goto fail;
1675
1676                         /*
1677                          * Full match found, return nvp and idx if this
1678                          * was the last component.
1679                          */
1680                         if (sepp == NULL) {
1681                                 if (ret)
1682                                         *ret = nvp;
1683                                 if (ip && idxp)
1684                                         *ip = (int)idx; /* return index */
1685                                 return (0);             /* found */
1686                         }
1687
1688                         /*
1689                          * More components: current match must be
1690                          * of DATA_TYPE_NVLIST or DATA_TYPE_NVLIST_ARRAY
1691                          * to support going deeper.
1692                          */
1693                         if (nvpair_type(nvp) == DATA_TYPE_NVLIST) {
1694                                 nvl = EMBEDDED_NVL(nvp);
1695                                 break;
1696                         } else if (nvpair_type(nvp) == DATA_TYPE_NVLIST_ARRAY) {
1697                                 (void) nvpair_value_nvlist_array(nvp,
1698                                     &nva, (uint_t *)&n);
1699                                 if ((n < 0) || (idx >= n))
1700                                         goto fail;
1701                                 nvl = nva[idx];
1702                                 break;
1703                         }
1704
1705                         /* type does not support more levels */
1706                         goto fail;
1707                 }
1708                 if (nvp == NULL)
1709                         goto fail;              /* 'name' not found */
1710
1711                 /* search for match of next component in embedded 'nvl' list */
1712         }
1713
1714 fail:   if (ep && sepp)
1715                 *ep = sepp;
1716         return (EINVAL);
1717 }
1718
1719 /*
1720  * Return pointer to nvpair with specified 'name'.
1721  */
1722 int
1723 nvlist_lookup_nvpair(nvlist_t *nvl, const char *name, nvpair_t **ret)
1724 {
1725         return (nvlist_lookup_nvpair_ei_sep(nvl, name, 0, ret, NULL, NULL));
1726 }
1727
1728 /*
1729  * Determine if named nvpair exists in nvlist (use embedded separator of '.'
1730  * and return array index).  See nvlist_lookup_nvpair_ei_sep for more detailed
1731  * description.
1732  */
1733 int nvlist_lookup_nvpair_embedded_index(nvlist_t *nvl,
1734     const char *name, nvpair_t **ret, int *ip, char **ep)
1735 {
1736         return (nvlist_lookup_nvpair_ei_sep(nvl, name, '.', ret, ip, ep));
1737 }
1738
1739 boolean_t
1740 nvlist_exists(nvlist_t *nvl, const char *name)
1741 {
1742         nvpriv_t *priv;
1743         nvpair_t *nvp;
1744         i_nvp_t *curr;
1745
1746         if (name == NULL || nvl == NULL ||
1747             (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
1748                 return (B_FALSE);
1749
1750         for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) {
1751                 nvp = &curr->nvi_nvp;
1752
1753                 if (strcmp(name, NVP_NAME(nvp)) == 0)
1754                         return (B_TRUE);
1755         }
1756
1757         return (B_FALSE);
1758 }
1759
1760 int
1761 nvpair_value_boolean_value(nvpair_t *nvp, boolean_t *val)
1762 {
1763         return (nvpair_value_common(nvp, DATA_TYPE_BOOLEAN_VALUE, NULL, val));
1764 }
1765
1766 int
1767 nvpair_value_byte(nvpair_t *nvp, uchar_t *val)
1768 {
1769         return (nvpair_value_common(nvp, DATA_TYPE_BYTE, NULL, val));
1770 }
1771
1772 int
1773 nvpair_value_int8(nvpair_t *nvp, int8_t *val)
1774 {
1775         return (nvpair_value_common(nvp, DATA_TYPE_INT8, NULL, val));
1776 }
1777
1778 int
1779 nvpair_value_uint8(nvpair_t *nvp, uint8_t *val)
1780 {
1781         return (nvpair_value_common(nvp, DATA_TYPE_UINT8, NULL, val));
1782 }
1783
1784 int
1785 nvpair_value_int16(nvpair_t *nvp, int16_t *val)
1786 {
1787         return (nvpair_value_common(nvp, DATA_TYPE_INT16, NULL, val));
1788 }
1789
1790 int
1791 nvpair_value_uint16(nvpair_t *nvp, uint16_t *val)
1792 {
1793         return (nvpair_value_common(nvp, DATA_TYPE_UINT16, NULL, val));
1794 }
1795
1796 int
1797 nvpair_value_int32(nvpair_t *nvp, int32_t *val)
1798 {
1799         return (nvpair_value_common(nvp, DATA_TYPE_INT32, NULL, val));
1800 }
1801
1802 int
1803 nvpair_value_uint32(nvpair_t *nvp, uint32_t *val)
1804 {
1805         return (nvpair_value_common(nvp, DATA_TYPE_UINT32, NULL, val));
1806 }
1807
1808 int
1809 nvpair_value_int64(nvpair_t *nvp, int64_t *val)
1810 {
1811         return (nvpair_value_common(nvp, DATA_TYPE_INT64, NULL, val));
1812 }
1813
1814 int
1815 nvpair_value_uint64(nvpair_t *nvp, uint64_t *val)
1816 {
1817         return (nvpair_value_common(nvp, DATA_TYPE_UINT64, NULL, val));
1818 }
1819
1820 #if !defined(_KERNEL)
1821 int
1822 nvpair_value_double(nvpair_t *nvp, double *val)
1823 {
1824         return (nvpair_value_common(nvp, DATA_TYPE_DOUBLE, NULL, val));
1825 }
1826 #endif
1827
1828 int
1829 nvpair_value_string(nvpair_t *nvp, char **val)
1830 {
1831         return (nvpair_value_common(nvp, DATA_TYPE_STRING, NULL, val));
1832 }
1833
1834 int
1835 nvpair_value_nvlist(nvpair_t *nvp, nvlist_t **val)
1836 {
1837         return (nvpair_value_common(nvp, DATA_TYPE_NVLIST, NULL, val));
1838 }
1839
1840 int
1841 nvpair_value_boolean_array(nvpair_t *nvp, boolean_t **val, uint_t *nelem)
1842 {
1843         return (nvpair_value_common(nvp, DATA_TYPE_BOOLEAN_ARRAY, nelem, val));
1844 }
1845
1846 int
1847 nvpair_value_byte_array(nvpair_t *nvp, uchar_t **val, uint_t *nelem)
1848 {
1849         return (nvpair_value_common(nvp, DATA_TYPE_BYTE_ARRAY, nelem, val));
1850 }
1851
1852 int
1853 nvpair_value_int8_array(nvpair_t *nvp, int8_t **val, uint_t *nelem)
1854 {
1855         return (nvpair_value_common(nvp, DATA_TYPE_INT8_ARRAY, nelem, val));
1856 }
1857
1858 int
1859 nvpair_value_uint8_array(nvpair_t *nvp, uint8_t **val, uint_t *nelem)
1860 {
1861         return (nvpair_value_common(nvp, DATA_TYPE_UINT8_ARRAY, nelem, val));
1862 }
1863
1864 int
1865 nvpair_value_int16_array(nvpair_t *nvp, int16_t **val, uint_t *nelem)
1866 {
1867         return (nvpair_value_common(nvp, DATA_TYPE_INT16_ARRAY, nelem, val));
1868 }
1869
1870 int
1871 nvpair_value_uint16_array(nvpair_t *nvp, uint16_t **val, uint_t *nelem)
1872 {
1873         return (nvpair_value_common(nvp, DATA_TYPE_UINT16_ARRAY, nelem, val));
1874 }
1875
1876 int
1877 nvpair_value_int32_array(nvpair_t *nvp, int32_t **val, uint_t *nelem)
1878 {
1879         return (nvpair_value_common(nvp, DATA_TYPE_INT32_ARRAY, nelem, val));
1880 }
1881
1882 int
1883 nvpair_value_uint32_array(nvpair_t *nvp, uint32_t **val, uint_t *nelem)
1884 {
1885         return (nvpair_value_common(nvp, DATA_TYPE_UINT32_ARRAY, nelem, val));
1886 }
1887
1888 int
1889 nvpair_value_int64_array(nvpair_t *nvp, int64_t **val, uint_t *nelem)
1890 {
1891         return (nvpair_value_common(nvp, DATA_TYPE_INT64_ARRAY, nelem, val));
1892 }
1893
1894 int
1895 nvpair_value_uint64_array(nvpair_t *nvp, uint64_t **val, uint_t *nelem)
1896 {
1897         return (nvpair_value_common(nvp, DATA_TYPE_UINT64_ARRAY, nelem, val));
1898 }
1899
1900 int
1901 nvpair_value_string_array(nvpair_t *nvp, char ***val, uint_t *nelem)
1902 {
1903         return (nvpair_value_common(nvp, DATA_TYPE_STRING_ARRAY, nelem, val));
1904 }
1905
1906 int
1907 nvpair_value_nvlist_array(nvpair_t *nvp, nvlist_t ***val, uint_t *nelem)
1908 {
1909         return (nvpair_value_common(nvp, DATA_TYPE_NVLIST_ARRAY, nelem, val));
1910 }
1911
1912 int
1913 nvpair_value_hrtime(nvpair_t *nvp, hrtime_t *val)
1914 {
1915         return (nvpair_value_common(nvp, DATA_TYPE_HRTIME, NULL, val));
1916 }
1917
1918 /*
1919  * Add specified pair to the list.
1920  */
1921 int
1922 nvlist_add_nvpair(nvlist_t *nvl, nvpair_t *nvp)
1923 {
1924         if (nvl == NULL || nvp == NULL)
1925                 return (EINVAL);
1926
1927         return (nvlist_add_common(nvl, NVP_NAME(nvp), NVP_TYPE(nvp),
1928             NVP_NELEM(nvp), NVP_VALUE(nvp)));
1929 }
1930
1931 /*
1932  * Merge the supplied nvlists and put the result in dst.
1933  * The merged list will contain all names specified in both lists,
1934  * the values are taken from nvl in the case of duplicates.
1935  * Return 0 on success.
1936  */
1937 /*ARGSUSED*/
1938 int
1939 nvlist_merge(nvlist_t *dst, nvlist_t *nvl, int flag)
1940 {
1941         if (nvl == NULL || dst == NULL)
1942                 return (EINVAL);
1943
1944         if (dst != nvl)
1945                 return (nvlist_copy_pairs(nvl, dst));
1946
1947         return (0);
1948 }
1949
1950 /*
1951  * Encoding related routines
1952  */
1953 #define NVS_OP_ENCODE   0
1954 #define NVS_OP_DECODE   1
1955 #define NVS_OP_GETSIZE  2
1956
1957 typedef struct nvs_ops nvs_ops_t;
1958
1959 typedef struct {
1960         int             nvs_op;
1961         const nvs_ops_t *nvs_ops;
1962         void            *nvs_private;
1963         nvpriv_t        *nvs_priv;
1964 } nvstream_t;
1965
1966 /*
1967  * nvs operations are:
1968  *   - nvs_nvlist
1969  *     encoding / decoding of a nvlist header (nvlist_t)
1970  *     calculates the size used for header and end detection
1971  *
1972  *   - nvs_nvpair
1973  *     responsible for the first part of encoding / decoding of an nvpair
1974  *     calculates the decoded size of an nvpair
1975  *
1976  *   - nvs_nvp_op
1977  *     second part of encoding / decoding of an nvpair
1978  *
1979  *   - nvs_nvp_size
1980  *     calculates the encoding size of an nvpair
1981  *
1982  *   - nvs_nvl_fini
1983  *     encodes the end detection mark (zeros).
1984  */
1985 struct nvs_ops {
1986         int (*nvs_nvlist)(nvstream_t *, nvlist_t *, size_t *);
1987         int (*nvs_nvpair)(nvstream_t *, nvpair_t *, size_t *);
1988         int (*nvs_nvp_op)(nvstream_t *, nvpair_t *);
1989         int (*nvs_nvp_size)(nvstream_t *, nvpair_t *, size_t *);
1990         int (*nvs_nvl_fini)(nvstream_t *);
1991 };
1992
1993 typedef struct {
1994         char    nvh_encoding;   /* nvs encoding method */
1995         char    nvh_endian;     /* nvs endian */
1996         char    nvh_reserved1;  /* reserved for future use */
1997         char    nvh_reserved2;  /* reserved for future use */
1998 } nvs_header_t;
1999
2000 static int
2001 nvs_encode_pairs(nvstream_t *nvs, nvlist_t *nvl)
2002 {
2003         nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv;
2004         i_nvp_t *curr;
2005
2006         /*
2007          * Walk nvpair in list and encode each nvpair
2008          */
2009         for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next)
2010                 if (nvs->nvs_ops->nvs_nvpair(nvs, &curr->nvi_nvp, NULL) != 0)
2011                         return (EFAULT);
2012
2013         return (nvs->nvs_ops->nvs_nvl_fini(nvs));
2014 }
2015
2016 static int
2017 nvs_decode_pairs(nvstream_t *nvs, nvlist_t *nvl)
2018 {
2019         nvpair_t *nvp;
2020         size_t nvsize;
2021         int err;
2022
2023         /*
2024          * Get decoded size of next pair in stream, alloc
2025          * memory for nvpair_t, then decode the nvpair
2026          */
2027         while ((err = nvs->nvs_ops->nvs_nvpair(nvs, NULL, &nvsize)) == 0) {
2028                 if (nvsize == 0) /* end of list */
2029                         break;
2030
2031                 /* make sure len makes sense */
2032                 if (nvsize < NVP_SIZE_CALC(1, 0))
2033                         return (EFAULT);
2034
2035                 if ((nvp = nvp_buf_alloc(nvl, nvsize)) == NULL)
2036                         return (ENOMEM);
2037
2038                 if ((err = nvs->nvs_ops->nvs_nvp_op(nvs, nvp)) != 0) {
2039                         nvp_buf_free(nvl, nvp);
2040                         return (err);
2041                 }
2042
2043                 if (i_validate_nvpair(nvp) != 0) {
2044                         nvpair_free(nvp);
2045                         nvp_buf_free(nvl, nvp);
2046                         return (EFAULT);
2047                 }
2048
2049                 nvp_buf_link(nvl, nvp);
2050         }
2051         return (err);
2052 }
2053
2054 static int
2055 nvs_getsize_pairs(nvstream_t *nvs, nvlist_t *nvl, size_t *buflen)
2056 {
2057         nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv;
2058         i_nvp_t *curr;
2059         uint64_t nvsize = *buflen;
2060         size_t size;
2061
2062         /*
2063          * Get encoded size of nvpairs in nvlist
2064          */
2065         for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) {
2066                 if (nvs->nvs_ops->nvs_nvp_size(nvs, &curr->nvi_nvp, &size) != 0)
2067                         return (EINVAL);
2068
2069                 if ((nvsize += size) > INT32_MAX)
2070                         return (EINVAL);
2071         }
2072
2073         *buflen = nvsize;
2074         return (0);
2075 }
2076
2077 static int
2078 nvs_operation(nvstream_t *nvs, nvlist_t *nvl, size_t *buflen)
2079 {
2080         int err;
2081
2082         if (nvl->nvl_priv == 0)
2083                 return (EFAULT);
2084
2085         /*
2086          * Perform the operation, starting with header, then each nvpair
2087          */
2088         if ((err = nvs->nvs_ops->nvs_nvlist(nvs, nvl, buflen)) != 0)
2089                 return (err);
2090
2091         switch (nvs->nvs_op) {
2092         case NVS_OP_ENCODE:
2093                 err = nvs_encode_pairs(nvs, nvl);
2094                 break;
2095
2096         case NVS_OP_DECODE:
2097                 err = nvs_decode_pairs(nvs, nvl);
2098                 break;
2099
2100         case NVS_OP_GETSIZE:
2101                 err = nvs_getsize_pairs(nvs, nvl, buflen);
2102                 break;
2103
2104         default:
2105                 err = EINVAL;
2106         }
2107
2108         return (err);
2109 }
2110
2111 static int
2112 nvs_embedded(nvstream_t *nvs, nvlist_t *embedded)
2113 {
2114         switch (nvs->nvs_op) {
2115         case NVS_OP_ENCODE:
2116                 return (nvs_operation(nvs, embedded, NULL));
2117
2118         case NVS_OP_DECODE: {
2119                 nvpriv_t *priv;
2120                 int err;
2121
2122                 if (embedded->nvl_version != NV_VERSION)
2123                         return (ENOTSUP);
2124
2125                 if ((priv = nv_priv_alloc_embedded(nvs->nvs_priv)) == NULL)
2126                         return (ENOMEM);
2127
2128                 nvlist_init(embedded, embedded->nvl_nvflag, priv);
2129
2130                 if ((err = nvs_operation(nvs, embedded, NULL)) != 0)
2131                         nvlist_free(embedded);
2132                 return (err);
2133         }
2134         default:
2135                 break;
2136         }
2137
2138         return (EINVAL);
2139 }
2140
2141 static int
2142 nvs_embedded_nvl_array(nvstream_t *nvs, nvpair_t *nvp, size_t *size)
2143 {
2144         size_t nelem = NVP_NELEM(nvp);
2145         nvlist_t **nvlp = EMBEDDED_NVL_ARRAY(nvp);
2146         int i;
2147
2148         switch (nvs->nvs_op) {
2149         case NVS_OP_ENCODE:
2150                 for (i = 0; i < nelem; i++)
2151                         if (nvs_embedded(nvs, nvlp[i]) != 0)
2152                                 return (EFAULT);
2153                 break;
2154
2155         case NVS_OP_DECODE: {
2156                 size_t len = nelem * sizeof (uint64_t);
2157                 nvlist_t *embedded = (nvlist_t *)((uintptr_t)nvlp + len);
2158
2159                 bzero(nvlp, len);       /* don't trust packed data */
2160                 for (i = 0; i < nelem; i++) {
2161                         if (nvs_embedded(nvs, embedded) != 0) {
2162                                 nvpair_free(nvp);
2163                                 return (EFAULT);
2164                         }
2165
2166                         nvlp[i] = embedded++;
2167                 }
2168                 break;
2169         }
2170         case NVS_OP_GETSIZE: {
2171                 uint64_t nvsize = 0;
2172
2173                 for (i = 0; i < nelem; i++) {
2174                         size_t nvp_sz = 0;
2175
2176                         if (nvs_operation(nvs, nvlp[i], &nvp_sz) != 0)
2177                                 return (EINVAL);
2178
2179                         if ((nvsize += nvp_sz) > INT32_MAX)
2180                                 return (EINVAL);
2181                 }
2182
2183                 *size = nvsize;
2184                 break;
2185         }
2186         default:
2187                 return (EINVAL);
2188         }
2189
2190         return (0);
2191 }
2192
2193 static int nvs_native(nvstream_t *, nvlist_t *, char *, size_t *);
2194 static int nvs_xdr(nvstream_t *, nvlist_t *, char *, size_t *);
2195
2196 /*
2197  * Common routine for nvlist operations:
2198  * encode, decode, getsize (encoded size).
2199  */
2200 static int
2201 nvlist_common(nvlist_t *nvl, char *buf, size_t *buflen, int encoding,
2202     int nvs_op)
2203 {
2204         int err = 0;
2205         nvstream_t nvs;
2206         int nvl_endian;
2207 #ifdef  _LITTLE_ENDIAN
2208         int host_endian = 1;
2209 #else
2210         int host_endian = 0;
2211 #endif  /* _LITTLE_ENDIAN */
2212         nvs_header_t *nvh = (void *)buf;
2213
2214         if (buflen == NULL || nvl == NULL ||
2215             (nvs.nvs_priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL)
2216                 return (EINVAL);
2217
2218         nvs.nvs_op = nvs_op;
2219
2220         /*
2221          * For NVS_OP_ENCODE and NVS_OP_DECODE make sure an nvlist and
2222          * a buffer is allocated.  The first 4 bytes in the buffer are
2223          * used for encoding method and host endian.
2224          */
2225         switch (nvs_op) {
2226         case NVS_OP_ENCODE:
2227                 if (buf == NULL || *buflen < sizeof (nvs_header_t))
2228                         return (EINVAL);
2229
2230                 nvh->nvh_encoding = encoding;
2231                 nvh->nvh_endian = nvl_endian = host_endian;
2232                 nvh->nvh_reserved1 = 0;
2233                 nvh->nvh_reserved2 = 0;
2234                 break;
2235
2236         case NVS_OP_DECODE:
2237                 if (buf == NULL || *buflen < sizeof (nvs_header_t))
2238                         return (EINVAL);
2239
2240                 /* get method of encoding from first byte */
2241                 encoding = nvh->nvh_encoding;
2242                 nvl_endian = nvh->nvh_endian;
2243                 break;
2244
2245         case NVS_OP_GETSIZE:
2246                 nvl_endian = host_endian;
2247
2248                 /*
2249                  * add the size for encoding
2250                  */
2251                 *buflen = sizeof (nvs_header_t);
2252                 break;
2253
2254         default:
2255                 return (ENOTSUP);
2256         }
2257
2258         /*
2259          * Create an nvstream with proper encoding method
2260          */
2261         switch (encoding) {
2262         case NV_ENCODE_NATIVE:
2263                 /*
2264                  * check endianness, in case we are unpacking
2265                  * from a file
2266                  */
2267                 if (nvl_endian != host_endian)
2268                         return (ENOTSUP);
2269                 err = nvs_native(&nvs, nvl, buf, buflen);
2270                 break;
2271         case NV_ENCODE_XDR:
2272                 err = nvs_xdr(&nvs, nvl, buf, buflen);
2273                 break;
2274         default:
2275                 err = ENOTSUP;
2276                 break;
2277         }
2278
2279         return (err);
2280 }
2281
2282 int
2283 nvlist_size(nvlist_t *nvl, size_t *size, int encoding)
2284 {
2285         return (nvlist_common(nvl, NULL, size, encoding, NVS_OP_GETSIZE));
2286 }
2287
2288 /*
2289  * Pack nvlist into contiguous memory
2290  */
2291 /*ARGSUSED1*/
2292 int
2293 nvlist_pack(nvlist_t *nvl, char **bufp, size_t *buflen, int encoding,
2294     int kmflag)
2295 {
2296 #if defined(_KERNEL) && !defined(_BOOT)
2297         return (nvlist_xpack(nvl, bufp, buflen, encoding,
2298             (kmflag == KM_SLEEP ? nv_alloc_sleep : nv_alloc_nosleep)));
2299 #else
2300         return (nvlist_xpack(nvl, bufp, buflen, encoding, nv_alloc_nosleep));
2301 #endif
2302 }
2303
2304 int
2305 nvlist_xpack(nvlist_t *nvl, char **bufp, size_t *buflen, int encoding,
2306     nv_alloc_t *nva)
2307 {
2308         nvpriv_t nvpriv;
2309         size_t alloc_size;
2310         char *buf;
2311         int err;
2312
2313         if (nva == NULL || nvl == NULL || bufp == NULL || buflen == NULL)
2314                 return (EINVAL);
2315
2316         if (*bufp != NULL)
2317                 return (nvlist_common(nvl, *bufp, buflen, encoding,
2318                     NVS_OP_ENCODE));
2319
2320         /*
2321          * Here is a difficult situation:
2322          * 1. The nvlist has fixed allocator properties.
2323          *    All other nvlist routines (like nvlist_add_*, ...) use
2324          *    these properties.
2325          * 2. When using nvlist_pack() the user can specify his own
2326          *    allocator properties (e.g. by using KM_NOSLEEP).
2327          *
2328          * We use the user specified properties (2). A clearer solution
2329          * will be to remove the kmflag from nvlist_pack(), but we will
2330          * not change the interface.
2331          */
2332         nv_priv_init(&nvpriv, nva, 0);
2333
2334         if (err = nvlist_size(nvl, &alloc_size, encoding))
2335                 return (err);
2336
2337         if ((buf = nv_mem_zalloc(&nvpriv, alloc_size)) == NULL)
2338                 return (ENOMEM);
2339
2340         if ((err = nvlist_common(nvl, buf, &alloc_size, encoding,
2341             NVS_OP_ENCODE)) != 0) {
2342                 nv_mem_free(&nvpriv, buf, alloc_size);
2343         } else {
2344                 *buflen = alloc_size;
2345                 *bufp = buf;
2346         }
2347
2348         return (err);
2349 }
2350
2351 /*
2352  * Unpack buf into an nvlist_t
2353  */
2354 /*ARGSUSED1*/
2355 int
2356 nvlist_unpack(char *buf, size_t buflen, nvlist_t **nvlp, int kmflag)
2357 {
2358 #if defined(_KERNEL) && !defined(_BOOT)
2359         return (nvlist_xunpack(buf, buflen, nvlp,
2360             (kmflag == KM_SLEEP ? nv_alloc_sleep : nv_alloc_nosleep)));
2361 #else
2362         return (nvlist_xunpack(buf, buflen, nvlp, nv_alloc_nosleep));
2363 #endif
2364 }
2365
2366 int
2367 nvlist_xunpack(char *buf, size_t buflen, nvlist_t **nvlp, nv_alloc_t *nva)
2368 {
2369         nvlist_t *nvl;
2370         int err;
2371
2372         if (nvlp == NULL)
2373                 return (EINVAL);
2374
2375         if ((err = nvlist_xalloc(&nvl, 0, nva)) != 0)
2376                 return (err);
2377
2378         if ((err = nvlist_common(nvl, buf, &buflen, 0, NVS_OP_DECODE)) != 0)
2379                 nvlist_free(nvl);
2380         else
2381                 *nvlp = nvl;
2382
2383         return (err);
2384 }
2385
2386 /*
2387  * Native encoding functions
2388  */
2389 typedef struct {
2390         /*
2391          * This structure is used when decoding a packed nvpair in
2392          * the native format.  n_base points to a buffer containing the
2393          * packed nvpair.  n_end is a pointer to the end of the buffer.
2394          * (n_end actually points to the first byte past the end of the
2395          * buffer.)  n_curr is a pointer that lies between n_base and n_end.
2396          * It points to the current data that we are decoding.
2397          * The amount of data left in the buffer is equal to n_end - n_curr.
2398          * n_flag is used to recognize a packed embedded list.
2399          */
2400         caddr_t n_base;
2401         caddr_t n_end;
2402         caddr_t n_curr;
2403         uint_t  n_flag;
2404 } nvs_native_t;
2405
2406 static int
2407 nvs_native_create(nvstream_t *nvs, nvs_native_t *native, char *buf,
2408     size_t buflen)
2409 {
2410         switch (nvs->nvs_op) {
2411         case NVS_OP_ENCODE:
2412         case NVS_OP_DECODE:
2413                 nvs->nvs_private = native;
2414                 native->n_curr = native->n_base = buf;
2415                 native->n_end = buf + buflen;
2416                 native->n_flag = 0;
2417                 return (0);
2418
2419         case NVS_OP_GETSIZE:
2420                 nvs->nvs_private = native;
2421                 native->n_curr = native->n_base = native->n_end = NULL;
2422                 native->n_flag = 0;
2423                 return (0);
2424         default:
2425                 return (EINVAL);
2426         }
2427 }
2428
2429 /*ARGSUSED*/
2430 static void
2431 nvs_native_destroy(nvstream_t *nvs)
2432 {
2433 }
2434
2435 static int
2436 native_cp(nvstream_t *nvs, void *buf, size_t size)
2437 {
2438         nvs_native_t *native = (nvs_native_t *)nvs->nvs_private;
2439
2440         if (native->n_curr + size > native->n_end)
2441                 return (EFAULT);
2442
2443         /*
2444          * The bcopy() below eliminates alignment requirement
2445          * on the buffer (stream) and is preferred over direct access.
2446          */
2447         switch (nvs->nvs_op) {
2448         case NVS_OP_ENCODE:
2449                 bcopy(buf, native->n_curr, size);
2450                 break;
2451         case NVS_OP_DECODE:
2452                 bcopy(native->n_curr, buf, size);
2453                 break;
2454         default:
2455                 return (EINVAL);
2456         }
2457
2458         native->n_curr += size;
2459         return (0);
2460 }
2461
2462 /*
2463  * operate on nvlist_t header
2464  */
2465 static int
2466 nvs_native_nvlist(nvstream_t *nvs, nvlist_t *nvl, size_t *size)
2467 {
2468         nvs_native_t *native = nvs->nvs_private;
2469
2470         switch (nvs->nvs_op) {
2471         case NVS_OP_ENCODE:
2472         case NVS_OP_DECODE:
2473                 if (native->n_flag)
2474                         return (0);     /* packed embedded list */
2475
2476                 native->n_flag = 1;
2477
2478                 /* copy version and nvflag of the nvlist_t */
2479                 if (native_cp(nvs, &nvl->nvl_version, sizeof (int32_t)) != 0 ||
2480                     native_cp(nvs, &nvl->nvl_nvflag, sizeof (int32_t)) != 0)
2481                         return (EFAULT);
2482
2483                 return (0);
2484
2485         case NVS_OP_GETSIZE:
2486                 /*
2487                  * if calculate for packed embedded list
2488                  *      4 for end of the embedded list
2489                  * else
2490                  *      2 * sizeof (int32_t) for nvl_version and nvl_nvflag
2491                  *      and 4 for end of the entire list
2492                  */
2493                 if (native->n_flag) {
2494                         *size += 4;
2495                 } else {
2496                         native->n_flag = 1;
2497                         *size += 2 * sizeof (int32_t) + 4;
2498                 }
2499
2500                 return (0);
2501
2502         default:
2503                 return (EINVAL);
2504         }
2505 }
2506
2507 static int
2508 nvs_native_nvl_fini(nvstream_t *nvs)
2509 {
2510         if (nvs->nvs_op == NVS_OP_ENCODE) {
2511                 nvs_native_t *native = (nvs_native_t *)nvs->nvs_private;
2512                 /*
2513                  * Add 4 zero bytes at end of nvlist. They are used
2514                  * for end detection by the decode routine.
2515                  */
2516                 if (native->n_curr + sizeof (int) > native->n_end)
2517                         return (EFAULT);
2518
2519                 bzero(native->n_curr, sizeof (int));
2520                 native->n_curr += sizeof (int);
2521         }
2522
2523         return (0);
2524 }
2525
2526 static int
2527 nvpair_native_embedded(nvstream_t *nvs, nvpair_t *nvp)
2528 {
2529         if (nvs->nvs_op == NVS_OP_ENCODE) {
2530                 nvs_native_t *native = (nvs_native_t *)nvs->nvs_private;
2531                 nvlist_t *packed = (void *)
2532                     (native->n_curr - nvp->nvp_size + NVP_VALOFF(nvp));
2533                 /*
2534                  * Null out the pointer that is meaningless in the packed
2535                  * structure. The address may not be aligned, so we have
2536                  * to use bzero.
2537                  */
2538                 bzero(&packed->nvl_priv, sizeof (packed->nvl_priv));
2539         }
2540
2541         return (nvs_embedded(nvs, EMBEDDED_NVL(nvp)));
2542 }
2543
2544 static int
2545 nvpair_native_embedded_array(nvstream_t *nvs, nvpair_t *nvp)
2546 {
2547         if (nvs->nvs_op == NVS_OP_ENCODE) {
2548                 nvs_native_t *native = (nvs_native_t *)nvs->nvs_private;
2549                 char *value = native->n_curr - nvp->nvp_size + NVP_VALOFF(nvp);
2550                 size_t len = NVP_NELEM(nvp) * sizeof (uint64_t);
2551                 nvlist_t *packed = (nvlist_t *)((uintptr_t)value + len);
2552                 int i;
2553                 /*
2554                  * Null out pointers that are meaningless in the packed
2555                  * structure. The addresses may not be aligned, so we have
2556                  * to use bzero.
2557                  */
2558                 bzero(value, len);
2559
2560                 for (i = 0; i < NVP_NELEM(nvp); i++, packed++)
2561                         /*
2562                          * Null out the pointer that is meaningless in the
2563                          * packed structure. The address may not be aligned,
2564                          * so we have to use bzero.
2565                          */
2566                         bzero(&packed->nvl_priv, sizeof (packed->nvl_priv));
2567         }
2568
2569         return (nvs_embedded_nvl_array(nvs, nvp, NULL));
2570 }
2571
2572 static void
2573 nvpair_native_string_array(nvstream_t *nvs, nvpair_t *nvp)
2574 {
2575         switch (nvs->nvs_op) {
2576         case NVS_OP_ENCODE: {
2577                 nvs_native_t *native = (nvs_native_t *)nvs->nvs_private;
2578                 uint64_t *strp = (void *)
2579                     (native->n_curr - nvp->nvp_size + NVP_VALOFF(nvp));
2580                 /*
2581                  * Null out pointers that are meaningless in the packed
2582                  * structure. The addresses may not be aligned, so we have
2583                  * to use bzero.
2584                  */
2585                 bzero(strp, NVP_NELEM(nvp) * sizeof (uint64_t));
2586                 break;
2587         }
2588         case NVS_OP_DECODE: {
2589                 char **strp = (void *)NVP_VALUE(nvp);
2590                 char *buf = ((char *)strp + NVP_NELEM(nvp) * sizeof (uint64_t));
2591                 int i;
2592
2593                 for (i = 0; i < NVP_NELEM(nvp); i++) {
2594                         strp[i] = buf;
2595                         buf += strlen(buf) + 1;
2596                 }
2597                 break;
2598         }
2599         }
2600 }
2601
2602 static int
2603 nvs_native_nvp_op(nvstream_t *nvs, nvpair_t *nvp)
2604 {
2605         data_type_t type;
2606         int value_sz;
2607         int ret = 0;
2608
2609         /*
2610          * We do the initial bcopy of the data before we look at
2611          * the nvpair type, because when we're decoding, we won't
2612          * have the correct values for the pair until we do the bcopy.
2613          */
2614         switch (nvs->nvs_op) {
2615         case NVS_OP_ENCODE:
2616         case NVS_OP_DECODE:
2617                 if (native_cp(nvs, nvp, nvp->nvp_size) != 0)
2618                         return (EFAULT);
2619                 break;
2620         default:
2621                 return (EINVAL);
2622         }
2623
2624         /* verify nvp_name_sz, check the name string length */
2625         if (i_validate_nvpair_name(nvp) != 0)
2626                 return (EFAULT);
2627
2628         type = NVP_TYPE(nvp);
2629
2630         /*
2631          * Verify type and nelem and get the value size.
2632          * In case of data types DATA_TYPE_STRING and DATA_TYPE_STRING_ARRAY
2633          * is the size of the string(s) excluded.
2634          */
2635         if ((value_sz = i_get_value_size(type, NULL, NVP_NELEM(nvp))) < 0)
2636                 return (EFAULT);
2637
2638         if (NVP_SIZE_CALC(nvp->nvp_name_sz, value_sz) > nvp->nvp_size)
2639                 return (EFAULT);
2640
2641         switch (type) {
2642         case DATA_TYPE_NVLIST:
2643                 ret = nvpair_native_embedded(nvs, nvp);
2644                 break;
2645         case DATA_TYPE_NVLIST_ARRAY:
2646                 ret = nvpair_native_embedded_array(nvs, nvp);
2647                 break;
2648         case DATA_TYPE_STRING_ARRAY:
2649                 nvpair_native_string_array(nvs, nvp);
2650                 break;
2651         default:
2652                 break;
2653         }
2654
2655         return (ret);
2656 }
2657
2658 static int
2659 nvs_native_nvp_size(nvstream_t *nvs, nvpair_t *nvp, size_t *size)
2660 {
2661         uint64_t nvp_sz = nvp->nvp_size;
2662
2663         switch (NVP_TYPE(nvp)) {
2664         case DATA_TYPE_NVLIST: {
2665                 size_t nvsize = 0;
2666
2667                 if (nvs_operation(nvs, EMBEDDED_NVL(nvp), &nvsize) != 0)
2668                         return (EINVAL);
2669
2670                 nvp_sz += nvsize;
2671                 break;
2672         }
2673         case DATA_TYPE_NVLIST_ARRAY: {
2674                 size_t nvsize;
2675
2676                 if (nvs_embedded_nvl_array(nvs, nvp, &nvsize) != 0)
2677                         return (EINVAL);
2678
2679                 nvp_sz += nvsize;
2680                 break;
2681         }
2682         default:
2683                 break;
2684         }
2685
2686         if (nvp_sz > INT32_MAX)
2687                 return (EINVAL);
2688
2689         *size = nvp_sz;
2690
2691         return (0);
2692 }
2693
2694 static int
2695 nvs_native_nvpair(nvstream_t *nvs, nvpair_t *nvp, size_t *size)
2696 {
2697         switch (nvs->nvs_op) {
2698         case NVS_OP_ENCODE:
2699                 return (nvs_native_nvp_op(nvs, nvp));
2700
2701         case NVS_OP_DECODE: {
2702                 nvs_native_t *native = (nvs_native_t *)nvs->nvs_private;
2703                 int32_t decode_len;
2704
2705                 /* try to read the size value from the stream */
2706                 if (native->n_curr + sizeof (int32_t) > native->n_end)
2707                         return (EFAULT);
2708                 bcopy(native->n_curr, &decode_len, sizeof (int32_t));
2709
2710                 /* sanity check the size value */
2711                 if (decode_len < 0 ||
2712                     decode_len > native->n_end - native->n_curr)
2713                         return (EFAULT);
2714
2715                 *size = decode_len;
2716
2717                 /*
2718                  * If at the end of the stream then move the cursor
2719                  * forward, otherwise nvpair_native_op() will read
2720                  * the entire nvpair at the same cursor position.
2721                  */
2722                 if (*size == 0)
2723                         native->n_curr += sizeof (int32_t);
2724                 break;
2725         }
2726
2727         default:
2728                 return (EINVAL);
2729         }
2730
2731         return (0);
2732 }
2733
2734 static const nvs_ops_t nvs_native_ops = {
2735         nvs_native_nvlist,
2736         nvs_native_nvpair,
2737         nvs_native_nvp_op,
2738         nvs_native_nvp_size,
2739         nvs_native_nvl_fini
2740 };
2741
2742 static int
2743 nvs_native(nvstream_t *nvs, nvlist_t *nvl, char *buf, size_t *buflen)
2744 {
2745         nvs_native_t native;
2746         int err;
2747
2748         nvs->nvs_ops = &nvs_native_ops;
2749
2750         if ((err = nvs_native_create(nvs, &native, buf + sizeof (nvs_header_t),
2751             *buflen - sizeof (nvs_header_t))) != 0)
2752                 return (err);
2753
2754         err = nvs_operation(nvs, nvl, buflen);
2755
2756         nvs_native_destroy(nvs);
2757
2758         return (err);
2759 }
2760
2761 /*
2762  * XDR encoding functions
2763  *
2764  * An xdr packed nvlist is encoded as:
2765  *
2766  *  - encoding methode and host endian (4 bytes)
2767  *  - nvl_version (4 bytes)
2768  *  - nvl_nvflag (4 bytes)
2769  *
2770  *  - encoded nvpairs, the format of one xdr encoded nvpair is:
2771  *      - encoded size of the nvpair (4 bytes)
2772  *      - decoded size of the nvpair (4 bytes)
2773  *      - name string, (4 + sizeof(NV_ALIGN4(string))
2774  *        a string is coded as size (4 bytes) and data
2775  *      - data type (4 bytes)
2776  *      - number of elements in the nvpair (4 bytes)
2777  *      - data
2778  *
2779  *  - 2 zero's for end of the entire list (8 bytes)
2780  */
2781 static int
2782 nvs_xdr_create(nvstream_t *nvs, XDR *xdr, char *buf, size_t buflen)
2783 {
2784         /* xdr data must be 4 byte aligned */
2785         if ((ulong_t)buf % 4 != 0)
2786                 return (EFAULT);
2787
2788         switch (nvs->nvs_op) {
2789         case NVS_OP_ENCODE:
2790                 xdrmem_create(xdr, buf, (uint_t)buflen, XDR_ENCODE);
2791                 nvs->nvs_private = xdr;
2792                 return (0);
2793         case NVS_OP_DECODE:
2794                 xdrmem_create(xdr, buf, (uint_t)buflen, XDR_DECODE);
2795                 nvs->nvs_private = xdr;
2796                 return (0);
2797         case NVS_OP_GETSIZE:
2798                 nvs->nvs_private = NULL;
2799                 return (0);
2800         default:
2801                 return (EINVAL);
2802         }
2803 }
2804
2805 static void
2806 nvs_xdr_destroy(nvstream_t *nvs)
2807 {
2808         switch (nvs->nvs_op) {
2809         case NVS_OP_ENCODE:
2810         case NVS_OP_DECODE:
2811                 xdr_destroy((XDR *)nvs->nvs_private);
2812                 break;
2813         default:
2814                 break;
2815         }
2816 }
2817
2818 static int
2819 nvs_xdr_nvlist(nvstream_t *nvs, nvlist_t *nvl, size_t *size)
2820 {
2821         switch (nvs->nvs_op) {
2822         case NVS_OP_ENCODE:
2823         case NVS_OP_DECODE: {
2824                 XDR     *xdr = nvs->nvs_private;
2825
2826                 if (!xdr_int(xdr, &nvl->nvl_version) ||
2827                     !xdr_u_int(xdr, &nvl->nvl_nvflag))
2828                         return (EFAULT);
2829                 break;
2830         }
2831         case NVS_OP_GETSIZE: {
2832                 /*
2833                  * 2 * 4 for nvl_version + nvl_nvflag
2834                  * and 8 for end of the entire list
2835                  */
2836                 *size += 2 * 4 + 8;
2837                 break;
2838         }
2839         default:
2840                 return (EINVAL);
2841         }
2842         return (0);
2843 }
2844
2845 static int
2846 nvs_xdr_nvl_fini(nvstream_t *nvs)
2847 {
2848         if (nvs->nvs_op == NVS_OP_ENCODE) {
2849                 XDR *xdr = nvs->nvs_private;
2850                 int zero = 0;
2851
2852                 if (!xdr_int(xdr, &zero) || !xdr_int(xdr, &zero))
2853                         return (EFAULT);
2854         }
2855
2856         return (0);
2857 }
2858
2859 /*
2860  * The format of xdr encoded nvpair is:
2861  * encode_size, decode_size, name string, data type, nelem, data
2862  */
2863 static int
2864 nvs_xdr_nvp_op(nvstream_t *nvs, nvpair_t *nvp)
2865 {
2866         data_type_t type;
2867         char    *buf;
2868         char    *buf_end = (char *)nvp + nvp->nvp_size;
2869         int     value_sz;
2870         uint_t  nelem, buflen;
2871         bool_t  ret = FALSE;
2872         XDR     *xdr = nvs->nvs_private;
2873
2874         ASSERT(xdr != NULL && nvp != NULL);
2875
2876         /* name string */
2877         if ((buf = NVP_NAME(nvp)) >= buf_end)
2878                 return (EFAULT);
2879         buflen = buf_end - buf;
2880
2881         if (!xdr_string(xdr, &buf, buflen - 1))
2882                 return (EFAULT);
2883         nvp->nvp_name_sz = strlen(buf) + 1;
2884
2885         /* type and nelem */
2886         if (!xdr_int(xdr, (int *)&nvp->nvp_type) ||
2887             !xdr_int(xdr, &nvp->nvp_value_elem))
2888                 return (EFAULT);
2889
2890         type = NVP_TYPE(nvp);
2891         nelem = nvp->nvp_value_elem;
2892
2893         /*
2894          * Verify type and nelem and get the value size.
2895          * In case of data types DATA_TYPE_STRING and DATA_TYPE_STRING_ARRAY
2896          * is the size of the string(s) excluded.
2897          */
2898         if ((value_sz = i_get_value_size(type, NULL, nelem)) < 0)
2899                 return (EFAULT);
2900
2901         /* if there is no data to extract then return */
2902         if (nelem == 0)
2903                 return (0);
2904
2905         /* value */
2906         if ((buf = NVP_VALUE(nvp)) >= buf_end)
2907                 return (EFAULT);
2908         buflen = buf_end - buf;
2909
2910         if (buflen < value_sz)
2911                 return (EFAULT);
2912
2913         switch (type) {
2914         case DATA_TYPE_NVLIST:
2915                 if (nvs_embedded(nvs, (void *)buf) == 0)
2916                         return (0);
2917                 break;
2918
2919         case DATA_TYPE_NVLIST_ARRAY:
2920                 if (nvs_embedded_nvl_array(nvs, nvp, NULL) == 0)
2921                         return (0);
2922                 break;
2923
2924         case DATA_TYPE_BOOLEAN:
2925                 ret = TRUE;
2926                 break;
2927
2928         case DATA_TYPE_BYTE:
2929         case DATA_TYPE_INT8:
2930         case DATA_TYPE_UINT8:
2931                 ret = xdr_char(xdr, buf);
2932                 break;
2933
2934         case DATA_TYPE_INT16:
2935                 ret = xdr_short(xdr, (void *)buf);
2936                 break;
2937
2938         case DATA_TYPE_UINT16:
2939                 ret = xdr_u_short(xdr, (void *)buf);
2940                 break;
2941
2942         case DATA_TYPE_BOOLEAN_VALUE:
2943         case DATA_TYPE_INT32:
2944                 ret = xdr_int(xdr, (void *)buf);
2945                 break;
2946
2947         case DATA_TYPE_UINT32:
2948                 ret = xdr_u_int(xdr, (void *)buf);
2949                 break;
2950
2951         case DATA_TYPE_INT64:
2952                 ret = xdr_longlong_t(xdr, (void *)buf);
2953                 break;
2954
2955         case DATA_TYPE_UINT64:
2956                 ret = xdr_u_longlong_t(xdr, (void *)buf);
2957                 break;
2958
2959         case DATA_TYPE_HRTIME:
2960                 /*
2961                  * NOTE: must expose the definition of hrtime_t here
2962                  */
2963                 ret = xdr_longlong_t(xdr, (void *)buf);
2964                 break;
2965 #if !defined(_KERNEL)
2966         case DATA_TYPE_DOUBLE:
2967                 ret = xdr_double(xdr, (void *)buf);
2968                 break;
2969 #endif
2970         case DATA_TYPE_STRING:
2971                 ret = xdr_string(xdr, &buf, buflen - 1);
2972                 break;
2973
2974         case DATA_TYPE_BYTE_ARRAY:
2975                 ret = xdr_opaque(xdr, buf, nelem);
2976                 break;
2977
2978         case DATA_TYPE_INT8_ARRAY:
2979         case DATA_TYPE_UINT8_ARRAY:
2980                 ret = xdr_array(xdr, &buf, &nelem, buflen, sizeof (int8_t),
2981                     (xdrproc_t)xdr_char);
2982                 break;
2983
2984         case DATA_TYPE_INT16_ARRAY:
2985                 ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (int16_t),
2986                     sizeof (int16_t), (xdrproc_t)xdr_short);
2987                 break;
2988
2989         case DATA_TYPE_UINT16_ARRAY:
2990                 ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (uint16_t),
2991                     sizeof (uint16_t), (xdrproc_t)xdr_u_short);
2992                 break;
2993
2994         case DATA_TYPE_BOOLEAN_ARRAY:
2995         case DATA_TYPE_INT32_ARRAY:
2996                 ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (int32_t),
2997                     sizeof (int32_t), (xdrproc_t)xdr_int);
2998                 break;
2999
3000         case DATA_TYPE_UINT32_ARRAY:
3001                 ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (uint32_t),
3002                     sizeof (uint32_t), (xdrproc_t)xdr_u_int);
3003                 break;
3004
3005         case DATA_TYPE_INT64_ARRAY:
3006                 ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (int64_t),
3007                     sizeof (int64_t), (xdrproc_t)xdr_longlong_t);
3008                 break;
3009
3010         case DATA_TYPE_UINT64_ARRAY:
3011                 ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (uint64_t),
3012                     sizeof (uint64_t), (xdrproc_t)xdr_u_longlong_t);
3013                 break;
3014
3015         case DATA_TYPE_STRING_ARRAY: {
3016                 size_t len = nelem * sizeof (uint64_t);
3017                 char **strp = (void *)buf;
3018                 int i;
3019
3020                 if (nvs->nvs_op == NVS_OP_DECODE)
3021                         bzero(buf, len);        /* don't trust packed data */
3022
3023                 for (i = 0; i < nelem; i++) {
3024                         if (buflen <= len)
3025                                 return (EFAULT);
3026
3027                         buf += len;
3028                         buflen -= len;
3029
3030                         if (xdr_string(xdr, &buf, buflen - 1) != TRUE)
3031                                 return (EFAULT);
3032
3033                         if (nvs->nvs_op == NVS_OP_DECODE)
3034                                 strp[i] = buf;
3035                         len = strlen(buf) + 1;
3036                 }
3037                 ret = TRUE;
3038                 break;
3039         }
3040         default:
3041                 break;
3042         }
3043
3044         return (ret == TRUE ? 0 : EFAULT);
3045 }
3046
3047 static int
3048 nvs_xdr_nvp_size(nvstream_t *nvs, nvpair_t *nvp, size_t *size)
3049 {
3050         data_type_t type = NVP_TYPE(nvp);
3051         /*
3052          * encode_size + decode_size + name string size + data type + nelem
3053          * where name string size = 4 + NV_ALIGN4(strlen(NVP_NAME(nvp)))
3054          */
3055         uint64_t nvp_sz = 4 + 4 + 4 + NV_ALIGN4(strlen(NVP_NAME(nvp))) + 4 + 4;
3056
3057         switch (type) {
3058         case DATA_TYPE_BOOLEAN:
3059                 break;
3060
3061         case DATA_TYPE_BOOLEAN_VALUE:
3062         case DATA_TYPE_BYTE:
3063         case DATA_TYPE_INT8:
3064         case DATA_TYPE_UINT8:
3065         case DATA_TYPE_INT16:
3066         case DATA_TYPE_UINT16:
3067         case DATA_TYPE_INT32:
3068         case DATA_TYPE_UINT32:
3069                 nvp_sz += 4;    /* 4 is the minimum xdr unit */
3070                 break;
3071
3072         case DATA_TYPE_INT64:
3073         case DATA_TYPE_UINT64:
3074         case DATA_TYPE_HRTIME:
3075 #if !defined(_KERNEL)
3076         case DATA_TYPE_DOUBLE:
3077 #endif
3078                 nvp_sz += 8;
3079                 break;
3080
3081         case DATA_TYPE_STRING:
3082                 nvp_sz += 4 + NV_ALIGN4(strlen((char *)NVP_VALUE(nvp)));
3083                 break;
3084
3085         case DATA_TYPE_BYTE_ARRAY:
3086                 nvp_sz += NV_ALIGN4(NVP_NELEM(nvp));
3087                 break;
3088
3089         case DATA_TYPE_BOOLEAN_ARRAY:
3090         case DATA_TYPE_INT8_ARRAY:
3091         case DATA_TYPE_UINT8_ARRAY:
3092         case DATA_TYPE_INT16_ARRAY:
3093         case DATA_TYPE_UINT16_ARRAY:
3094         case DATA_TYPE_INT32_ARRAY:
3095         case DATA_TYPE_UINT32_ARRAY:
3096                 nvp_sz += 4 + 4 * (uint64_t)NVP_NELEM(nvp);
3097                 break;
3098
3099         case DATA_TYPE_INT64_ARRAY:
3100         case DATA_TYPE_UINT64_ARRAY:
3101                 nvp_sz += 4 + 8 * (uint64_t)NVP_NELEM(nvp);
3102                 break;
3103
3104         case DATA_TYPE_STRING_ARRAY: {
3105                 int i;
3106                 char **strs = (void *)NVP_VALUE(nvp);
3107
3108                 for (i = 0; i < NVP_NELEM(nvp); i++)
3109                         nvp_sz += 4 + NV_ALIGN4(strlen(strs[i]));
3110
3111                 break;
3112         }
3113
3114         case DATA_TYPE_NVLIST:
3115         case DATA_TYPE_NVLIST_ARRAY: {
3116                 size_t nvsize = 0;
3117                 int old_nvs_op = nvs->nvs_op;
3118                 int err;
3119
3120                 nvs->nvs_op = NVS_OP_GETSIZE;
3121                 if (type == DATA_TYPE_NVLIST)
3122                         err = nvs_operation(nvs, EMBEDDED_NVL(nvp), &nvsize);
3123                 else
3124                         err = nvs_embedded_nvl_array(nvs, nvp, &nvsize);
3125                 nvs->nvs_op = old_nvs_op;
3126
3127                 if (err != 0)
3128                         return (EINVAL);
3129
3130                 nvp_sz += nvsize;
3131                 break;
3132         }
3133
3134         default:
3135                 return (EINVAL);
3136         }
3137
3138         if (nvp_sz > INT32_MAX)
3139                 return (EINVAL);
3140
3141         *size = nvp_sz;
3142
3143         return (0);
3144 }
3145
3146
3147 /*
3148  * The NVS_XDR_MAX_LEN macro takes a packed xdr buffer of size x and estimates
3149  * the largest nvpair that could be encoded in the buffer.
3150  *
3151  * See comments above nvpair_xdr_op() for the format of xdr encoding.
3152  * The size of a xdr packed nvpair without any data is 5 words.
3153  *
3154  * Using the size of the data directly as an estimate would be ok
3155  * in all cases except one.  If the data type is of DATA_TYPE_STRING_ARRAY
3156  * then the actual nvpair has space for an array of pointers to index
3157  * the strings.  These pointers are not encoded into the packed xdr buffer.
3158  *
3159  * If the data is of type DATA_TYPE_STRING_ARRAY and all the strings are
3160  * of length 0, then each string is endcoded in xdr format as a single word.
3161  * Therefore when expanded to an nvpair there will be 2.25 word used for
3162  * each string.  (a int64_t allocated for pointer usage, and a single char
3163  * for the null termination.)
3164  *
3165  * This is the calculation performed by the NVS_XDR_MAX_LEN macro.
3166  */
3167 #define NVS_XDR_HDR_LEN         ((size_t)(5 * 4))
3168 #define NVS_XDR_DATA_LEN(y)     (((size_t)(y) <= NVS_XDR_HDR_LEN) ? \
3169                                         0 : ((size_t)(y) - NVS_XDR_HDR_LEN))
3170 #define NVS_XDR_MAX_LEN(x)      (NVP_SIZE_CALC(1, 0) + \
3171                                         (NVS_XDR_DATA_LEN(x) * 2) + \
3172                                         NV_ALIGN4((NVS_XDR_DATA_LEN(x) / 4)))
3173
3174 static int
3175 nvs_xdr_nvpair(nvstream_t *nvs, nvpair_t *nvp, size_t *size)
3176 {
3177         XDR     *xdr = nvs->nvs_private;
3178         int32_t encode_len, decode_len;
3179
3180         switch (nvs->nvs_op) {
3181         case NVS_OP_ENCODE: {
3182                 size_t nvsize;
3183
3184                 if (nvs_xdr_nvp_size(nvs, nvp, &nvsize) != 0)
3185                         return (EFAULT);
3186
3187                 decode_len = nvp->nvp_size;
3188                 encode_len = nvsize;
3189                 if (!xdr_int(xdr, &encode_len) || !xdr_int(xdr, &decode_len))
3190                         return (EFAULT);
3191
3192                 return (nvs_xdr_nvp_op(nvs, nvp));
3193         }
3194         case NVS_OP_DECODE: {
3195                 struct xdr_bytesrec bytesrec;
3196
3197                 /* get the encode and decode size */
3198                 if (!xdr_int(xdr, &encode_len) || !xdr_int(xdr, &decode_len))
3199                         return (EFAULT);
3200                 *size = decode_len;
3201
3202                 /* are we at the end of the stream? */
3203                 if (*size == 0)
3204                         return (0);
3205
3206                 /* sanity check the size parameter */
3207                 if (!xdr_control(xdr, XDR_GET_BYTES_AVAIL, &bytesrec))
3208                         return (EFAULT);
3209
3210                 if (*size > NVS_XDR_MAX_LEN(bytesrec.xc_num_avail))
3211                         return (EFAULT);
3212                 break;
3213         }
3214
3215         default:
3216                 return (EINVAL);
3217         }
3218         return (0);
3219 }
3220
3221 static const struct nvs_ops nvs_xdr_ops = {
3222         nvs_xdr_nvlist,
3223         nvs_xdr_nvpair,
3224         nvs_xdr_nvp_op,
3225         nvs_xdr_nvp_size,
3226         nvs_xdr_nvl_fini
3227 };
3228
3229 static int
3230 nvs_xdr(nvstream_t *nvs, nvlist_t *nvl, char *buf, size_t *buflen)
3231 {
3232         XDR xdr;
3233         int err;
3234
3235         nvs->nvs_ops = &nvs_xdr_ops;
3236
3237         if ((err = nvs_xdr_create(nvs, &xdr, buf + sizeof (nvs_header_t),
3238             *buflen - sizeof (nvs_header_t))) != 0)
3239                 return (err);
3240
3241         err = nvs_operation(nvs, nvl, buflen);
3242
3243         nvs_xdr_destroy(nvs);
3244
3245         return (err);
3246 }