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