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