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