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