17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 53bb79becSeschrock * Common Development and Distribution License (the "License"). 63bb79becSeschrock * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 21d9638e54Smws 227c478bd9Sstevel@tonic-gate /* 23*602ca9eaScth * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate #include <sys/stropts.h> 307c478bd9Sstevel@tonic-gate #include <sys/debug.h> 317c478bd9Sstevel@tonic-gate #include <sys/isa_defs.h> 327c478bd9Sstevel@tonic-gate #include <sys/int_limits.h> 337c478bd9Sstevel@tonic-gate #include <sys/nvpair.h> 347c478bd9Sstevel@tonic-gate #include <sys/nvpair_impl.h> 357c478bd9Sstevel@tonic-gate #include <rpc/types.h> 367c478bd9Sstevel@tonic-gate #include <rpc/xdr.h> 377c478bd9Sstevel@tonic-gate 387c478bd9Sstevel@tonic-gate #if defined(_KERNEL) && !defined(_BOOT) 397c478bd9Sstevel@tonic-gate #include <sys/varargs.h> 40*602ca9eaScth #include <sys/ddi.h> 41*602ca9eaScth #include <sys/sunddi.h> 427c478bd9Sstevel@tonic-gate #else 437c478bd9Sstevel@tonic-gate #include <stdarg.h> 44*602ca9eaScth #include <stdlib.h> 45*602ca9eaScth #include <string.h> 467c478bd9Sstevel@tonic-gate #include <strings.h> 477c478bd9Sstevel@tonic-gate #endif 487c478bd9Sstevel@tonic-gate 497c478bd9Sstevel@tonic-gate #ifndef offsetof 50*602ca9eaScth #define offsetof(s, m) ((size_t)(&(((s *)0)->m))) 517c478bd9Sstevel@tonic-gate #endif 52*602ca9eaScth #define skip_whitespace(p) while ((*(p) == ' ') || (*(p) == '\t')) p++ 537c478bd9Sstevel@tonic-gate 547c478bd9Sstevel@tonic-gate /* 557c478bd9Sstevel@tonic-gate * nvpair.c - Provides kernel & userland interfaces for manipulating 567c478bd9Sstevel@tonic-gate * name-value pairs. 577c478bd9Sstevel@tonic-gate * 587c478bd9Sstevel@tonic-gate * Overview Diagram 597c478bd9Sstevel@tonic-gate * 607c478bd9Sstevel@tonic-gate * +--------------+ 617c478bd9Sstevel@tonic-gate * | nvlist_t | 627c478bd9Sstevel@tonic-gate * |--------------| 637c478bd9Sstevel@tonic-gate * | nvl_version | 647c478bd9Sstevel@tonic-gate * | nvl_nvflag | 657c478bd9Sstevel@tonic-gate * | nvl_priv -+-+ 667c478bd9Sstevel@tonic-gate * | nvl_flag | | 677c478bd9Sstevel@tonic-gate * | nvl_pad | | 687c478bd9Sstevel@tonic-gate * +--------------+ | 697c478bd9Sstevel@tonic-gate * V 707c478bd9Sstevel@tonic-gate * +--------------+ last i_nvp in list 717c478bd9Sstevel@tonic-gate * | nvpriv_t | +---------------------> 727c478bd9Sstevel@tonic-gate * |--------------| | 737c478bd9Sstevel@tonic-gate * +--+- nvp_list | | +------------+ 747c478bd9Sstevel@tonic-gate * | | nvp_last -+--+ + nv_alloc_t | 757c478bd9Sstevel@tonic-gate * | | nvp_curr | |------------| 767c478bd9Sstevel@tonic-gate * | | nvp_nva -+----> | nva_ops | 777c478bd9Sstevel@tonic-gate * | | nvp_stat | | nva_arg | 787c478bd9Sstevel@tonic-gate * | +--------------+ +------------+ 797c478bd9Sstevel@tonic-gate * | 807c478bd9Sstevel@tonic-gate * +-------+ 817c478bd9Sstevel@tonic-gate * V 827c478bd9Sstevel@tonic-gate * +---------------------+ +-------------------+ 837c478bd9Sstevel@tonic-gate * | i_nvp_t | +-->| i_nvp_t | +--> 847c478bd9Sstevel@tonic-gate * |---------------------| | |-------------------| | 857c478bd9Sstevel@tonic-gate * | nvi_next -+--+ | nvi_next -+--+ 867c478bd9Sstevel@tonic-gate * | nvi_prev (NULL) | <----+ nvi_prev | 877c478bd9Sstevel@tonic-gate * | . . . . . . . . . . | | . . . . . . . . . | 887c478bd9Sstevel@tonic-gate * | nvp (nvpair_t) | | nvp (nvpair_t) | 897c478bd9Sstevel@tonic-gate * | - nvp_size | | - nvp_size | 907c478bd9Sstevel@tonic-gate * | - nvp_name_sz | | - nvp_name_sz | 917c478bd9Sstevel@tonic-gate * | - nvp_value_elem | | - nvp_value_elem | 927c478bd9Sstevel@tonic-gate * | - nvp_type | | - nvp_type | 937c478bd9Sstevel@tonic-gate * | - data ... | | - data ... | 947c478bd9Sstevel@tonic-gate * +---------------------+ +-------------------+ 957c478bd9Sstevel@tonic-gate * 967c478bd9Sstevel@tonic-gate * 977c478bd9Sstevel@tonic-gate * 987c478bd9Sstevel@tonic-gate * +---------------------+ +---------------------+ 997c478bd9Sstevel@tonic-gate * | i_nvp_t | +--> +-->| i_nvp_t (last) | 1007c478bd9Sstevel@tonic-gate * |---------------------| | | |---------------------| 1017c478bd9Sstevel@tonic-gate * | nvi_next -+--+ ... --+ | nvi_next (NULL) | 1027c478bd9Sstevel@tonic-gate * <-+- nvi_prev |<-- ... <----+ nvi_prev | 1037c478bd9Sstevel@tonic-gate * | . . . . . . . . . | | . . . . . . . . . | 1047c478bd9Sstevel@tonic-gate * | nvp (nvpair_t) | | nvp (nvpair_t) | 1057c478bd9Sstevel@tonic-gate * | - nvp_size | | - nvp_size | 1067c478bd9Sstevel@tonic-gate * | - nvp_name_sz | | - nvp_name_sz | 1077c478bd9Sstevel@tonic-gate * | - nvp_value_elem | | - nvp_value_elem | 1087c478bd9Sstevel@tonic-gate * | - DATA_TYPE_NVLIST | | - nvp_type | 1097c478bd9Sstevel@tonic-gate * | - data (embedded) | | - data ... | 1107c478bd9Sstevel@tonic-gate * | nvlist name | +---------------------+ 1117c478bd9Sstevel@tonic-gate * | +--------------+ | 1127c478bd9Sstevel@tonic-gate * | | nvlist_t | | 1137c478bd9Sstevel@tonic-gate * | |--------------| | 1147c478bd9Sstevel@tonic-gate * | | nvl_version | | 1157c478bd9Sstevel@tonic-gate * | | nvl_nvflag | | 1167c478bd9Sstevel@tonic-gate * | | nvl_priv --+---+----> 1177c478bd9Sstevel@tonic-gate * | | nvl_flag | | 1187c478bd9Sstevel@tonic-gate * | | nvl_pad | | 1197c478bd9Sstevel@tonic-gate * | +--------------+ | 1207c478bd9Sstevel@tonic-gate * +---------------------+ 1217c478bd9Sstevel@tonic-gate * 1227c478bd9Sstevel@tonic-gate * 1237c478bd9Sstevel@tonic-gate * N.B. nvpair_t may be aligned on 4 byte boundary, so +4 will 1247c478bd9Sstevel@tonic-gate * allow value to be aligned on 8 byte boundary 1257c478bd9Sstevel@tonic-gate * 1267c478bd9Sstevel@tonic-gate * name_len is the length of the name string including the null terminator 1277c478bd9Sstevel@tonic-gate * so it must be >= 1 1287c478bd9Sstevel@tonic-gate */ 1297c478bd9Sstevel@tonic-gate #define NVP_SIZE_CALC(name_len, data_len) \ 1307c478bd9Sstevel@tonic-gate (NV_ALIGN((sizeof (nvpair_t)) + name_len) + NV_ALIGN(data_len)) 1317c478bd9Sstevel@tonic-gate 1327c478bd9Sstevel@tonic-gate static int i_get_value_size(data_type_t type, const void *data, uint_t nelem); 1337c478bd9Sstevel@tonic-gate static int nvlist_add_common(nvlist_t *nvl, const char *name, data_type_t type, 1347c478bd9Sstevel@tonic-gate uint_t nelem, const void *data); 1357c478bd9Sstevel@tonic-gate 1367c478bd9Sstevel@tonic-gate #define NV_STAT_EMBEDDED 0x1 1377c478bd9Sstevel@tonic-gate #define EMBEDDED_NVL(nvp) ((nvlist_t *)(void *)NVP_VALUE(nvp)) 1387c478bd9Sstevel@tonic-gate #define EMBEDDED_NVL_ARRAY(nvp) ((nvlist_t **)(void *)NVP_VALUE(nvp)) 1397c478bd9Sstevel@tonic-gate 1407c478bd9Sstevel@tonic-gate #define NVP_VALOFF(nvp) (NV_ALIGN(sizeof (nvpair_t) + (nvp)->nvp_name_sz)) 1417c478bd9Sstevel@tonic-gate #define NVPAIR2I_NVP(nvp) \ 1427c478bd9Sstevel@tonic-gate ((i_nvp_t *)((size_t)(nvp) - offsetof(i_nvp_t, nvi_nvp))) 1437c478bd9Sstevel@tonic-gate 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate int 1467c478bd9Sstevel@tonic-gate nv_alloc_init(nv_alloc_t *nva, const nv_alloc_ops_t *nvo, /* args */ ...) 1477c478bd9Sstevel@tonic-gate { 1487c478bd9Sstevel@tonic-gate va_list valist; 1497c478bd9Sstevel@tonic-gate int err = 0; 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate nva->nva_ops = nvo; 1527c478bd9Sstevel@tonic-gate nva->nva_arg = NULL; 1537c478bd9Sstevel@tonic-gate 1547c478bd9Sstevel@tonic-gate va_start(valist, nvo); 1557c478bd9Sstevel@tonic-gate if (nva->nva_ops->nv_ao_init != NULL) 1567c478bd9Sstevel@tonic-gate err = nva->nva_ops->nv_ao_init(nva, valist); 1577c478bd9Sstevel@tonic-gate va_end(valist); 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate return (err); 1607c478bd9Sstevel@tonic-gate } 1617c478bd9Sstevel@tonic-gate 1627c478bd9Sstevel@tonic-gate void 1637c478bd9Sstevel@tonic-gate nv_alloc_reset(nv_alloc_t *nva) 1647c478bd9Sstevel@tonic-gate { 1657c478bd9Sstevel@tonic-gate if (nva->nva_ops->nv_ao_reset != NULL) 1667c478bd9Sstevel@tonic-gate nva->nva_ops->nv_ao_reset(nva); 1677c478bd9Sstevel@tonic-gate } 1687c478bd9Sstevel@tonic-gate 1697c478bd9Sstevel@tonic-gate void 1707c478bd9Sstevel@tonic-gate nv_alloc_fini(nv_alloc_t *nva) 1717c478bd9Sstevel@tonic-gate { 1727c478bd9Sstevel@tonic-gate if (nva->nva_ops->nv_ao_fini != NULL) 1737c478bd9Sstevel@tonic-gate nva->nva_ops->nv_ao_fini(nva); 1747c478bd9Sstevel@tonic-gate } 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate nv_alloc_t * 1777c478bd9Sstevel@tonic-gate nvlist_lookup_nv_alloc(nvlist_t *nvl) 1787c478bd9Sstevel@tonic-gate { 1797c478bd9Sstevel@tonic-gate nvpriv_t *priv; 1807c478bd9Sstevel@tonic-gate 1817c478bd9Sstevel@tonic-gate if (nvl == NULL || 1827c478bd9Sstevel@tonic-gate (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 1837c478bd9Sstevel@tonic-gate return (NULL); 1847c478bd9Sstevel@tonic-gate 1857c478bd9Sstevel@tonic-gate return (priv->nvp_nva); 1867c478bd9Sstevel@tonic-gate } 1877c478bd9Sstevel@tonic-gate 1887c478bd9Sstevel@tonic-gate static void * 1897c478bd9Sstevel@tonic-gate nv_mem_zalloc(nvpriv_t *nvp, size_t size) 1907c478bd9Sstevel@tonic-gate { 1917c478bd9Sstevel@tonic-gate nv_alloc_t *nva = nvp->nvp_nva; 1927c478bd9Sstevel@tonic-gate void *buf; 1937c478bd9Sstevel@tonic-gate 1947c478bd9Sstevel@tonic-gate if ((buf = nva->nva_ops->nv_ao_alloc(nva, size)) != NULL) 1957c478bd9Sstevel@tonic-gate bzero(buf, size); 1967c478bd9Sstevel@tonic-gate 1977c478bd9Sstevel@tonic-gate return (buf); 1987c478bd9Sstevel@tonic-gate } 1997c478bd9Sstevel@tonic-gate 2007c478bd9Sstevel@tonic-gate static void 2017c478bd9Sstevel@tonic-gate nv_mem_free(nvpriv_t *nvp, void *buf, size_t size) 2027c478bd9Sstevel@tonic-gate { 2037c478bd9Sstevel@tonic-gate nv_alloc_t *nva = nvp->nvp_nva; 2047c478bd9Sstevel@tonic-gate 2057c478bd9Sstevel@tonic-gate nva->nva_ops->nv_ao_free(nva, buf, size); 2067c478bd9Sstevel@tonic-gate } 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate static void 2097c478bd9Sstevel@tonic-gate nv_priv_init(nvpriv_t *priv, nv_alloc_t *nva, uint32_t stat) 2107c478bd9Sstevel@tonic-gate { 2117c478bd9Sstevel@tonic-gate bzero(priv, sizeof (priv)); 2127c478bd9Sstevel@tonic-gate 2137c478bd9Sstevel@tonic-gate priv->nvp_nva = nva; 2147c478bd9Sstevel@tonic-gate priv->nvp_stat = stat; 2157c478bd9Sstevel@tonic-gate } 2167c478bd9Sstevel@tonic-gate 2177c478bd9Sstevel@tonic-gate static nvpriv_t * 2187c478bd9Sstevel@tonic-gate nv_priv_alloc(nv_alloc_t *nva) 2197c478bd9Sstevel@tonic-gate { 2207c478bd9Sstevel@tonic-gate nvpriv_t *priv; 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate /* 2237c478bd9Sstevel@tonic-gate * nv_mem_alloc() cannot called here because it needs the priv 2247c478bd9Sstevel@tonic-gate * argument. 2257c478bd9Sstevel@tonic-gate */ 2267c478bd9Sstevel@tonic-gate if ((priv = nva->nva_ops->nv_ao_alloc(nva, sizeof (nvpriv_t))) == NULL) 2277c478bd9Sstevel@tonic-gate return (NULL); 2287c478bd9Sstevel@tonic-gate 2297c478bd9Sstevel@tonic-gate nv_priv_init(priv, nva, 0); 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate return (priv); 2327c478bd9Sstevel@tonic-gate } 2337c478bd9Sstevel@tonic-gate 2347c478bd9Sstevel@tonic-gate /* 2357c478bd9Sstevel@tonic-gate * Embedded lists need their own nvpriv_t's. We create a new 2367c478bd9Sstevel@tonic-gate * nvpriv_t using the parameters and allocator from the parent 2377c478bd9Sstevel@tonic-gate * list's nvpriv_t. 2387c478bd9Sstevel@tonic-gate */ 2397c478bd9Sstevel@tonic-gate static nvpriv_t * 2407c478bd9Sstevel@tonic-gate nv_priv_alloc_embedded(nvpriv_t *priv) 2417c478bd9Sstevel@tonic-gate { 2427c478bd9Sstevel@tonic-gate nvpriv_t *emb_priv; 2437c478bd9Sstevel@tonic-gate 2447c478bd9Sstevel@tonic-gate if ((emb_priv = nv_mem_zalloc(priv, sizeof (nvpriv_t))) == NULL) 2457c478bd9Sstevel@tonic-gate return (NULL); 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate nv_priv_init(emb_priv, priv->nvp_nva, NV_STAT_EMBEDDED); 2487c478bd9Sstevel@tonic-gate 2497c478bd9Sstevel@tonic-gate return (emb_priv); 2507c478bd9Sstevel@tonic-gate } 2517c478bd9Sstevel@tonic-gate 2527c478bd9Sstevel@tonic-gate static void 2537c478bd9Sstevel@tonic-gate nvlist_init(nvlist_t *nvl, uint32_t nvflag, nvpriv_t *priv) 2547c478bd9Sstevel@tonic-gate { 2557c478bd9Sstevel@tonic-gate nvl->nvl_version = NV_VERSION; 2567c478bd9Sstevel@tonic-gate nvl->nvl_nvflag = nvflag & (NV_UNIQUE_NAME|NV_UNIQUE_NAME_TYPE); 2577c478bd9Sstevel@tonic-gate nvl->nvl_priv = (uint64_t)(uintptr_t)priv; 2587c478bd9Sstevel@tonic-gate nvl->nvl_flag = 0; 2597c478bd9Sstevel@tonic-gate nvl->nvl_pad = 0; 2607c478bd9Sstevel@tonic-gate } 2617c478bd9Sstevel@tonic-gate 2627c478bd9Sstevel@tonic-gate /* 2637c478bd9Sstevel@tonic-gate * nvlist_alloc - Allocate nvlist. 2647c478bd9Sstevel@tonic-gate */ 2657c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 2667c478bd9Sstevel@tonic-gate int 2677c478bd9Sstevel@tonic-gate nvlist_alloc(nvlist_t **nvlp, uint_t nvflag, int kmflag) 2687c478bd9Sstevel@tonic-gate { 2697c478bd9Sstevel@tonic-gate #if defined(_KERNEL) && !defined(_BOOT) 2707c478bd9Sstevel@tonic-gate return (nvlist_xalloc(nvlp, nvflag, 2717c478bd9Sstevel@tonic-gate (kmflag == KM_SLEEP ? nv_alloc_sleep : nv_alloc_nosleep))); 2727c478bd9Sstevel@tonic-gate #else 2737c478bd9Sstevel@tonic-gate return (nvlist_xalloc(nvlp, nvflag, nv_alloc_nosleep)); 2747c478bd9Sstevel@tonic-gate #endif 2757c478bd9Sstevel@tonic-gate } 2767c478bd9Sstevel@tonic-gate 2777c478bd9Sstevel@tonic-gate int 2787c478bd9Sstevel@tonic-gate nvlist_xalloc(nvlist_t **nvlp, uint_t nvflag, nv_alloc_t *nva) 2797c478bd9Sstevel@tonic-gate { 2807c478bd9Sstevel@tonic-gate nvpriv_t *priv; 2817c478bd9Sstevel@tonic-gate 2827c478bd9Sstevel@tonic-gate if (nvlp == NULL || nva == NULL) 2837c478bd9Sstevel@tonic-gate return (EINVAL); 2847c478bd9Sstevel@tonic-gate 2857c478bd9Sstevel@tonic-gate if ((priv = nv_priv_alloc(nva)) == NULL) 2867c478bd9Sstevel@tonic-gate return (ENOMEM); 2877c478bd9Sstevel@tonic-gate 2887c478bd9Sstevel@tonic-gate if ((*nvlp = nv_mem_zalloc(priv, 2897c478bd9Sstevel@tonic-gate NV_ALIGN(sizeof (nvlist_t)))) == NULL) { 2907c478bd9Sstevel@tonic-gate nv_mem_free(priv, priv, sizeof (nvpriv_t)); 2917c478bd9Sstevel@tonic-gate return (ENOMEM); 2927c478bd9Sstevel@tonic-gate } 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate nvlist_init(*nvlp, nvflag, priv); 2957c478bd9Sstevel@tonic-gate 2967c478bd9Sstevel@tonic-gate return (0); 2977c478bd9Sstevel@tonic-gate } 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate /* 3007c478bd9Sstevel@tonic-gate * nvp_buf_alloc - Allocate i_nvp_t for storing a new nv pair. 3017c478bd9Sstevel@tonic-gate */ 3027c478bd9Sstevel@tonic-gate static nvpair_t * 3037c478bd9Sstevel@tonic-gate nvp_buf_alloc(nvlist_t *nvl, size_t len) 3047c478bd9Sstevel@tonic-gate { 3057c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 3067c478bd9Sstevel@tonic-gate i_nvp_t *buf; 3077c478bd9Sstevel@tonic-gate nvpair_t *nvp; 3087c478bd9Sstevel@tonic-gate size_t nvsize; 3097c478bd9Sstevel@tonic-gate 3107c478bd9Sstevel@tonic-gate /* 3117c478bd9Sstevel@tonic-gate * Allocate the buffer 3127c478bd9Sstevel@tonic-gate */ 3137c478bd9Sstevel@tonic-gate nvsize = len + offsetof(i_nvp_t, nvi_nvp); 3147c478bd9Sstevel@tonic-gate 3157c478bd9Sstevel@tonic-gate if ((buf = nv_mem_zalloc(priv, nvsize)) == NULL) 3167c478bd9Sstevel@tonic-gate return (NULL); 3177c478bd9Sstevel@tonic-gate 3187c478bd9Sstevel@tonic-gate nvp = &buf->nvi_nvp; 3197c478bd9Sstevel@tonic-gate nvp->nvp_size = len; 3207c478bd9Sstevel@tonic-gate 3217c478bd9Sstevel@tonic-gate return (nvp); 3227c478bd9Sstevel@tonic-gate } 3237c478bd9Sstevel@tonic-gate 3247c478bd9Sstevel@tonic-gate /* 3257c478bd9Sstevel@tonic-gate * nvp_buf_free - de-Allocate an i_nvp_t. 3267c478bd9Sstevel@tonic-gate */ 3277c478bd9Sstevel@tonic-gate static void 3287c478bd9Sstevel@tonic-gate nvp_buf_free(nvlist_t *nvl, nvpair_t *nvp) 3297c478bd9Sstevel@tonic-gate { 3307c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 3317c478bd9Sstevel@tonic-gate size_t nvsize = nvp->nvp_size + offsetof(i_nvp_t, nvi_nvp); 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate nv_mem_free(priv, NVPAIR2I_NVP(nvp), nvsize); 3347c478bd9Sstevel@tonic-gate } 3357c478bd9Sstevel@tonic-gate 3367c478bd9Sstevel@tonic-gate /* 3377c478bd9Sstevel@tonic-gate * nvp_buf_link - link a new nv pair into the nvlist. 3387c478bd9Sstevel@tonic-gate */ 3397c478bd9Sstevel@tonic-gate static void 3407c478bd9Sstevel@tonic-gate nvp_buf_link(nvlist_t *nvl, nvpair_t *nvp) 3417c478bd9Sstevel@tonic-gate { 3427c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 3437c478bd9Sstevel@tonic-gate i_nvp_t *curr = NVPAIR2I_NVP(nvp); 3447c478bd9Sstevel@tonic-gate 3457c478bd9Sstevel@tonic-gate /* Put element at end of nvlist */ 3467c478bd9Sstevel@tonic-gate if (priv->nvp_list == NULL) { 3477c478bd9Sstevel@tonic-gate priv->nvp_list = priv->nvp_last = curr; 3487c478bd9Sstevel@tonic-gate } else { 3497c478bd9Sstevel@tonic-gate curr->nvi_prev = priv->nvp_last; 3507c478bd9Sstevel@tonic-gate priv->nvp_last->nvi_next = curr; 3517c478bd9Sstevel@tonic-gate priv->nvp_last = curr; 3527c478bd9Sstevel@tonic-gate } 3537c478bd9Sstevel@tonic-gate } 3547c478bd9Sstevel@tonic-gate 3557c478bd9Sstevel@tonic-gate /* 3567c478bd9Sstevel@tonic-gate * nvp_buf_unlink - unlink an removed nvpair out of the nvlist. 3577c478bd9Sstevel@tonic-gate */ 3587c478bd9Sstevel@tonic-gate static void 3597c478bd9Sstevel@tonic-gate nvp_buf_unlink(nvlist_t *nvl, nvpair_t *nvp) 3607c478bd9Sstevel@tonic-gate { 3617c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 3627c478bd9Sstevel@tonic-gate i_nvp_t *curr = NVPAIR2I_NVP(nvp); 3637c478bd9Sstevel@tonic-gate 3647c478bd9Sstevel@tonic-gate /* 3657c478bd9Sstevel@tonic-gate * protect nvlist_next_nvpair() against walking on freed memory. 3667c478bd9Sstevel@tonic-gate */ 3677c478bd9Sstevel@tonic-gate if (priv->nvp_curr == curr) 3687c478bd9Sstevel@tonic-gate priv->nvp_curr = curr->nvi_next; 3697c478bd9Sstevel@tonic-gate 3707c478bd9Sstevel@tonic-gate if (curr == priv->nvp_list) 3717c478bd9Sstevel@tonic-gate priv->nvp_list = curr->nvi_next; 3727c478bd9Sstevel@tonic-gate else 3737c478bd9Sstevel@tonic-gate curr->nvi_prev->nvi_next = curr->nvi_next; 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate if (curr == priv->nvp_last) 3767c478bd9Sstevel@tonic-gate priv->nvp_last = curr->nvi_prev; 3777c478bd9Sstevel@tonic-gate else 3787c478bd9Sstevel@tonic-gate curr->nvi_next->nvi_prev = curr->nvi_prev; 3797c478bd9Sstevel@tonic-gate } 3807c478bd9Sstevel@tonic-gate 3817c478bd9Sstevel@tonic-gate /* 3827c478bd9Sstevel@tonic-gate * take a nvpair type and number of elements and make sure the are valid 3837c478bd9Sstevel@tonic-gate */ 3847c478bd9Sstevel@tonic-gate static int 3857c478bd9Sstevel@tonic-gate i_validate_type_nelem(data_type_t type, uint_t nelem) 3867c478bd9Sstevel@tonic-gate { 3877c478bd9Sstevel@tonic-gate switch (type) { 3887c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 3897c478bd9Sstevel@tonic-gate if (nelem != 0) 3907c478bd9Sstevel@tonic-gate return (EINVAL); 3917c478bd9Sstevel@tonic-gate break; 3927c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 3937c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE: 3947c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8: 3957c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8: 3967c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16: 3977c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16: 3987c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32: 3997c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32: 4007c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64: 4017c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64: 4027c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING: 4037c478bd9Sstevel@tonic-gate case DATA_TYPE_HRTIME: 4047c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 4057c478bd9Sstevel@tonic-gate if (nelem != 1) 4067c478bd9Sstevel@tonic-gate return (EINVAL); 4077c478bd9Sstevel@tonic-gate break; 4087c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: 4097c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE_ARRAY: 4107c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8_ARRAY: 4117c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8_ARRAY: 4127c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16_ARRAY: 4137c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16_ARRAY: 4147c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32_ARRAY: 4157c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32_ARRAY: 4167c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64_ARRAY: 4177c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64_ARRAY: 4187c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: 4197c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: 4207c478bd9Sstevel@tonic-gate /* we allow arrays with 0 elements */ 4217c478bd9Sstevel@tonic-gate break; 4227c478bd9Sstevel@tonic-gate default: 4237c478bd9Sstevel@tonic-gate return (EINVAL); 4247c478bd9Sstevel@tonic-gate } 4257c478bd9Sstevel@tonic-gate return (0); 4267c478bd9Sstevel@tonic-gate } 4277c478bd9Sstevel@tonic-gate 4287c478bd9Sstevel@tonic-gate /* 4297c478bd9Sstevel@tonic-gate * Verify nvp_name_sz and check the name string length. 4307c478bd9Sstevel@tonic-gate */ 4317c478bd9Sstevel@tonic-gate static int 4327c478bd9Sstevel@tonic-gate i_validate_nvpair_name(nvpair_t *nvp) 4337c478bd9Sstevel@tonic-gate { 4347c478bd9Sstevel@tonic-gate if ((nvp->nvp_name_sz <= 0) || 4357c478bd9Sstevel@tonic-gate (nvp->nvp_size < NVP_SIZE_CALC(nvp->nvp_name_sz, 0))) 4367c478bd9Sstevel@tonic-gate return (EFAULT); 4377c478bd9Sstevel@tonic-gate 4387c478bd9Sstevel@tonic-gate /* verify the name string, make sure its terminated */ 4397c478bd9Sstevel@tonic-gate if (NVP_NAME(nvp)[nvp->nvp_name_sz - 1] != '\0') 4407c478bd9Sstevel@tonic-gate return (EFAULT); 4417c478bd9Sstevel@tonic-gate 4427c478bd9Sstevel@tonic-gate return (strlen(NVP_NAME(nvp)) == nvp->nvp_name_sz - 1 ? 0 : EFAULT); 4437c478bd9Sstevel@tonic-gate } 4447c478bd9Sstevel@tonic-gate 4457c478bd9Sstevel@tonic-gate static int 4467c478bd9Sstevel@tonic-gate i_validate_nvpair_value(data_type_t type, uint_t nelem, const void *data) 4477c478bd9Sstevel@tonic-gate { 4487c478bd9Sstevel@tonic-gate switch (type) { 4497c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 4507c478bd9Sstevel@tonic-gate if (*(boolean_t *)data != B_TRUE && 4517c478bd9Sstevel@tonic-gate *(boolean_t *)data != B_FALSE) 4527c478bd9Sstevel@tonic-gate return (EINVAL); 4537c478bd9Sstevel@tonic-gate break; 4547c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: { 4557c478bd9Sstevel@tonic-gate int i; 4567c478bd9Sstevel@tonic-gate 4577c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) 4587c478bd9Sstevel@tonic-gate if (((boolean_t *)data)[i] != B_TRUE && 4597c478bd9Sstevel@tonic-gate ((boolean_t *)data)[i] != B_FALSE) 4607c478bd9Sstevel@tonic-gate return (EINVAL); 4617c478bd9Sstevel@tonic-gate break; 4627c478bd9Sstevel@tonic-gate } 4637c478bd9Sstevel@tonic-gate default: 4647c478bd9Sstevel@tonic-gate break; 4657c478bd9Sstevel@tonic-gate } 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate return (0); 4687c478bd9Sstevel@tonic-gate } 4697c478bd9Sstevel@tonic-gate 4707c478bd9Sstevel@tonic-gate /* 4717c478bd9Sstevel@tonic-gate * This function takes a pointer to what should be a nvpair and it's size 4727c478bd9Sstevel@tonic-gate * and then verifies that all the nvpair fields make sense and can be 4737c478bd9Sstevel@tonic-gate * trusted. This function is used when decoding packed nvpairs. 4747c478bd9Sstevel@tonic-gate */ 4757c478bd9Sstevel@tonic-gate static int 4767c478bd9Sstevel@tonic-gate i_validate_nvpair(nvpair_t *nvp) 4777c478bd9Sstevel@tonic-gate { 4787c478bd9Sstevel@tonic-gate data_type_t type = NVP_TYPE(nvp); 4797c478bd9Sstevel@tonic-gate int size1, size2; 4807c478bd9Sstevel@tonic-gate 4817c478bd9Sstevel@tonic-gate /* verify nvp_name_sz, check the name string length */ 4827c478bd9Sstevel@tonic-gate if (i_validate_nvpair_name(nvp) != 0) 4837c478bd9Sstevel@tonic-gate return (EFAULT); 4847c478bd9Sstevel@tonic-gate 4857c478bd9Sstevel@tonic-gate if (i_validate_nvpair_value(type, NVP_NELEM(nvp), NVP_VALUE(nvp)) != 0) 4867c478bd9Sstevel@tonic-gate return (EFAULT); 4877c478bd9Sstevel@tonic-gate 4887c478bd9Sstevel@tonic-gate /* 4897c478bd9Sstevel@tonic-gate * verify nvp_type, nvp_value_elem, and also possibly 4907c478bd9Sstevel@tonic-gate * verify string values and get the value size. 4917c478bd9Sstevel@tonic-gate */ 4927c478bd9Sstevel@tonic-gate size2 = i_get_value_size(type, NVP_VALUE(nvp), NVP_NELEM(nvp)); 4937c478bd9Sstevel@tonic-gate size1 = nvp->nvp_size - NVP_VALOFF(nvp); 4947c478bd9Sstevel@tonic-gate if (size2 < 0 || size1 != NV_ALIGN(size2)) 4957c478bd9Sstevel@tonic-gate return (EFAULT); 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate return (0); 4987c478bd9Sstevel@tonic-gate } 4997c478bd9Sstevel@tonic-gate 5007c478bd9Sstevel@tonic-gate static int 5017c478bd9Sstevel@tonic-gate nvlist_copy_pairs(nvlist_t *snvl, nvlist_t *dnvl) 5027c478bd9Sstevel@tonic-gate { 5037c478bd9Sstevel@tonic-gate nvpriv_t *priv; 5047c478bd9Sstevel@tonic-gate i_nvp_t *curr; 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate if ((priv = (nvpriv_t *)(uintptr_t)snvl->nvl_priv) == NULL) 5077c478bd9Sstevel@tonic-gate return (EINVAL); 5087c478bd9Sstevel@tonic-gate 5097c478bd9Sstevel@tonic-gate for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) { 5107c478bd9Sstevel@tonic-gate nvpair_t *nvp = &curr->nvi_nvp; 5117c478bd9Sstevel@tonic-gate int err; 5127c478bd9Sstevel@tonic-gate 5137c478bd9Sstevel@tonic-gate if ((err = nvlist_add_common(dnvl, NVP_NAME(nvp), NVP_TYPE(nvp), 5147c478bd9Sstevel@tonic-gate NVP_NELEM(nvp), NVP_VALUE(nvp))) != 0) 5157c478bd9Sstevel@tonic-gate return (err); 5167c478bd9Sstevel@tonic-gate } 5177c478bd9Sstevel@tonic-gate 5187c478bd9Sstevel@tonic-gate return (0); 5197c478bd9Sstevel@tonic-gate } 5207c478bd9Sstevel@tonic-gate 5217c478bd9Sstevel@tonic-gate /* 5227c478bd9Sstevel@tonic-gate * Frees all memory allocated for an nvpair (like embedded lists) with 5237c478bd9Sstevel@tonic-gate * the exception of the nvpair buffer itself. 5247c478bd9Sstevel@tonic-gate */ 5257c478bd9Sstevel@tonic-gate static void 5267c478bd9Sstevel@tonic-gate nvpair_free(nvpair_t *nvp) 5277c478bd9Sstevel@tonic-gate { 5287c478bd9Sstevel@tonic-gate switch (NVP_TYPE(nvp)) { 5297c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 5307c478bd9Sstevel@tonic-gate nvlist_free(EMBEDDED_NVL(nvp)); 5317c478bd9Sstevel@tonic-gate break; 5327c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: { 5337c478bd9Sstevel@tonic-gate nvlist_t **nvlp = EMBEDDED_NVL_ARRAY(nvp); 5347c478bd9Sstevel@tonic-gate int i; 5357c478bd9Sstevel@tonic-gate 5367c478bd9Sstevel@tonic-gate for (i = 0; i < NVP_NELEM(nvp); i++) 5377c478bd9Sstevel@tonic-gate if (nvlp[i] != NULL) 5387c478bd9Sstevel@tonic-gate nvlist_free(nvlp[i]); 5397c478bd9Sstevel@tonic-gate break; 5407c478bd9Sstevel@tonic-gate } 5417c478bd9Sstevel@tonic-gate default: 5427c478bd9Sstevel@tonic-gate break; 5437c478bd9Sstevel@tonic-gate } 5447c478bd9Sstevel@tonic-gate } 5457c478bd9Sstevel@tonic-gate 5467c478bd9Sstevel@tonic-gate /* 5477c478bd9Sstevel@tonic-gate * nvlist_free - free an unpacked nvlist 5487c478bd9Sstevel@tonic-gate */ 5497c478bd9Sstevel@tonic-gate void 5507c478bd9Sstevel@tonic-gate nvlist_free(nvlist_t *nvl) 5517c478bd9Sstevel@tonic-gate { 5527c478bd9Sstevel@tonic-gate nvpriv_t *priv; 5537c478bd9Sstevel@tonic-gate i_nvp_t *curr; 5547c478bd9Sstevel@tonic-gate 5557c478bd9Sstevel@tonic-gate if (nvl == NULL || 5567c478bd9Sstevel@tonic-gate (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 5577c478bd9Sstevel@tonic-gate return; 5587c478bd9Sstevel@tonic-gate 5597c478bd9Sstevel@tonic-gate /* 5607c478bd9Sstevel@tonic-gate * Unpacked nvlist are linked through i_nvp_t 5617c478bd9Sstevel@tonic-gate */ 5627c478bd9Sstevel@tonic-gate curr = priv->nvp_list; 5637c478bd9Sstevel@tonic-gate while (curr != NULL) { 5647c478bd9Sstevel@tonic-gate nvpair_t *nvp = &curr->nvi_nvp; 5657c478bd9Sstevel@tonic-gate curr = curr->nvi_next; 5667c478bd9Sstevel@tonic-gate 5677c478bd9Sstevel@tonic-gate nvpair_free(nvp); 5687c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 5697c478bd9Sstevel@tonic-gate } 5707c478bd9Sstevel@tonic-gate 5717c478bd9Sstevel@tonic-gate if (!(priv->nvp_stat & NV_STAT_EMBEDDED)) 5727c478bd9Sstevel@tonic-gate nv_mem_free(priv, nvl, NV_ALIGN(sizeof (nvlist_t))); 5737c478bd9Sstevel@tonic-gate else 5745ad82045Snd nvl->nvl_priv = 0; 5757c478bd9Sstevel@tonic-gate 5767c478bd9Sstevel@tonic-gate nv_mem_free(priv, priv, sizeof (nvpriv_t)); 5777c478bd9Sstevel@tonic-gate } 5787c478bd9Sstevel@tonic-gate 5797c478bd9Sstevel@tonic-gate static int 5807c478bd9Sstevel@tonic-gate nvlist_contains_nvp(nvlist_t *nvl, nvpair_t *nvp) 5817c478bd9Sstevel@tonic-gate { 5827c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 5837c478bd9Sstevel@tonic-gate i_nvp_t *curr; 5847c478bd9Sstevel@tonic-gate 5857c478bd9Sstevel@tonic-gate if (nvp == NULL) 5867c478bd9Sstevel@tonic-gate return (0); 5877c478bd9Sstevel@tonic-gate 5887c478bd9Sstevel@tonic-gate for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) 5897c478bd9Sstevel@tonic-gate if (&curr->nvi_nvp == nvp) 5907c478bd9Sstevel@tonic-gate return (1); 5917c478bd9Sstevel@tonic-gate 5927c478bd9Sstevel@tonic-gate return (0); 5937c478bd9Sstevel@tonic-gate } 5947c478bd9Sstevel@tonic-gate 5957c478bd9Sstevel@tonic-gate /* 5967c478bd9Sstevel@tonic-gate * Make a copy of nvlist 5977c478bd9Sstevel@tonic-gate */ 5987c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 5997c478bd9Sstevel@tonic-gate int 6007c478bd9Sstevel@tonic-gate nvlist_dup(nvlist_t *nvl, nvlist_t **nvlp, int kmflag) 6017c478bd9Sstevel@tonic-gate { 6027c478bd9Sstevel@tonic-gate #if defined(_KERNEL) && !defined(_BOOT) 6037c478bd9Sstevel@tonic-gate return (nvlist_xdup(nvl, nvlp, 6047c478bd9Sstevel@tonic-gate (kmflag == KM_SLEEP ? nv_alloc_sleep : nv_alloc_nosleep))); 6057c478bd9Sstevel@tonic-gate #else 6067c478bd9Sstevel@tonic-gate return (nvlist_xdup(nvl, nvlp, nv_alloc_nosleep)); 6077c478bd9Sstevel@tonic-gate #endif 6087c478bd9Sstevel@tonic-gate } 6097c478bd9Sstevel@tonic-gate 6107c478bd9Sstevel@tonic-gate int 6117c478bd9Sstevel@tonic-gate nvlist_xdup(nvlist_t *nvl, nvlist_t **nvlp, nv_alloc_t *nva) 6127c478bd9Sstevel@tonic-gate { 6137c478bd9Sstevel@tonic-gate int err; 6143bb79becSeschrock nvlist_t *ret; 6157c478bd9Sstevel@tonic-gate 6167c478bd9Sstevel@tonic-gate if (nvl == NULL || nvlp == NULL) 6177c478bd9Sstevel@tonic-gate return (EINVAL); 6187c478bd9Sstevel@tonic-gate 6193bb79becSeschrock if ((err = nvlist_xalloc(&ret, nvl->nvl_nvflag, nva)) != 0) 6207c478bd9Sstevel@tonic-gate return (err); 6217c478bd9Sstevel@tonic-gate 6223bb79becSeschrock if ((err = nvlist_copy_pairs(nvl, ret)) != 0) 6233bb79becSeschrock nvlist_free(ret); 6243bb79becSeschrock else 6253bb79becSeschrock *nvlp = ret; 6267c478bd9Sstevel@tonic-gate 6277c478bd9Sstevel@tonic-gate return (err); 6287c478bd9Sstevel@tonic-gate } 6297c478bd9Sstevel@tonic-gate 6307c478bd9Sstevel@tonic-gate /* 6317c478bd9Sstevel@tonic-gate * Remove all with matching name 6327c478bd9Sstevel@tonic-gate */ 6337c478bd9Sstevel@tonic-gate int 6347c478bd9Sstevel@tonic-gate nvlist_remove_all(nvlist_t *nvl, const char *name) 6357c478bd9Sstevel@tonic-gate { 6367c478bd9Sstevel@tonic-gate nvpriv_t *priv; 6377c478bd9Sstevel@tonic-gate i_nvp_t *curr; 6387c478bd9Sstevel@tonic-gate int error = ENOENT; 6397c478bd9Sstevel@tonic-gate 6407c478bd9Sstevel@tonic-gate if (nvl == NULL || name == NULL || 6417c478bd9Sstevel@tonic-gate (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 6427c478bd9Sstevel@tonic-gate return (EINVAL); 6437c478bd9Sstevel@tonic-gate 6447c478bd9Sstevel@tonic-gate curr = priv->nvp_list; 6457c478bd9Sstevel@tonic-gate while (curr != NULL) { 6467c478bd9Sstevel@tonic-gate nvpair_t *nvp = &curr->nvi_nvp; 6477c478bd9Sstevel@tonic-gate 6487c478bd9Sstevel@tonic-gate curr = curr->nvi_next; 6497c478bd9Sstevel@tonic-gate if (strcmp(name, NVP_NAME(nvp)) != 0) 6507c478bd9Sstevel@tonic-gate continue; 6517c478bd9Sstevel@tonic-gate 6527c478bd9Sstevel@tonic-gate nvp_buf_unlink(nvl, nvp); 6537c478bd9Sstevel@tonic-gate nvpair_free(nvp); 6547c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 6557c478bd9Sstevel@tonic-gate 6567c478bd9Sstevel@tonic-gate error = 0; 6577c478bd9Sstevel@tonic-gate } 6587c478bd9Sstevel@tonic-gate 6597c478bd9Sstevel@tonic-gate return (error); 6607c478bd9Sstevel@tonic-gate } 6617c478bd9Sstevel@tonic-gate 6627c478bd9Sstevel@tonic-gate /* 6637c478bd9Sstevel@tonic-gate * Remove first one with matching name and type 6647c478bd9Sstevel@tonic-gate */ 6657c478bd9Sstevel@tonic-gate int 6667c478bd9Sstevel@tonic-gate nvlist_remove(nvlist_t *nvl, const char *name, data_type_t type) 6677c478bd9Sstevel@tonic-gate { 6687c478bd9Sstevel@tonic-gate nvpriv_t *priv; 6697c478bd9Sstevel@tonic-gate i_nvp_t *curr; 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate if (nvl == NULL || name == NULL || 6727c478bd9Sstevel@tonic-gate (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 6737c478bd9Sstevel@tonic-gate return (EINVAL); 6747c478bd9Sstevel@tonic-gate 6757c478bd9Sstevel@tonic-gate curr = priv->nvp_list; 6767c478bd9Sstevel@tonic-gate while (curr != NULL) { 6777c478bd9Sstevel@tonic-gate nvpair_t *nvp = &curr->nvi_nvp; 6787c478bd9Sstevel@tonic-gate 6797c478bd9Sstevel@tonic-gate if (strcmp(name, NVP_NAME(nvp)) == 0 && NVP_TYPE(nvp) == type) { 6807c478bd9Sstevel@tonic-gate nvp_buf_unlink(nvl, nvp); 6817c478bd9Sstevel@tonic-gate nvpair_free(nvp); 6827c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 6837c478bd9Sstevel@tonic-gate 6847c478bd9Sstevel@tonic-gate return (0); 6857c478bd9Sstevel@tonic-gate } 6867c478bd9Sstevel@tonic-gate curr = curr->nvi_next; 6877c478bd9Sstevel@tonic-gate } 6887c478bd9Sstevel@tonic-gate 6897c478bd9Sstevel@tonic-gate return (ENOENT); 6907c478bd9Sstevel@tonic-gate } 6917c478bd9Sstevel@tonic-gate 6927c478bd9Sstevel@tonic-gate /* 6937c478bd9Sstevel@tonic-gate * This function calculates the size of an nvpair value. 6947c478bd9Sstevel@tonic-gate * 6957c478bd9Sstevel@tonic-gate * The data argument controls the behavior in case of the data types 6967c478bd9Sstevel@tonic-gate * DATA_TYPE_STRING and 6977c478bd9Sstevel@tonic-gate * DATA_TYPE_STRING_ARRAY 6987c478bd9Sstevel@tonic-gate * Is data == NULL then the size of the string(s) is excluded. 6997c478bd9Sstevel@tonic-gate */ 7007c478bd9Sstevel@tonic-gate static int 7017c478bd9Sstevel@tonic-gate i_get_value_size(data_type_t type, const void *data, uint_t nelem) 7027c478bd9Sstevel@tonic-gate { 7037c478bd9Sstevel@tonic-gate uint64_t value_sz; 7047c478bd9Sstevel@tonic-gate 7057c478bd9Sstevel@tonic-gate if (i_validate_type_nelem(type, nelem) != 0) 7067c478bd9Sstevel@tonic-gate return (-1); 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate /* Calculate required size for holding value */ 7097c478bd9Sstevel@tonic-gate switch (type) { 7107c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 7117c478bd9Sstevel@tonic-gate value_sz = 0; 7127c478bd9Sstevel@tonic-gate break; 7137c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 7147c478bd9Sstevel@tonic-gate value_sz = sizeof (boolean_t); 7157c478bd9Sstevel@tonic-gate break; 7167c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE: 7177c478bd9Sstevel@tonic-gate value_sz = sizeof (uchar_t); 7187c478bd9Sstevel@tonic-gate break; 7197c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8: 7207c478bd9Sstevel@tonic-gate value_sz = sizeof (int8_t); 7217c478bd9Sstevel@tonic-gate break; 7227c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8: 7237c478bd9Sstevel@tonic-gate value_sz = sizeof (uint8_t); 7247c478bd9Sstevel@tonic-gate break; 7257c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16: 7267c478bd9Sstevel@tonic-gate value_sz = sizeof (int16_t); 7277c478bd9Sstevel@tonic-gate break; 7287c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16: 7297c478bd9Sstevel@tonic-gate value_sz = sizeof (uint16_t); 7307c478bd9Sstevel@tonic-gate break; 7317c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32: 7327c478bd9Sstevel@tonic-gate value_sz = sizeof (int32_t); 7337c478bd9Sstevel@tonic-gate break; 7347c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32: 7357c478bd9Sstevel@tonic-gate value_sz = sizeof (uint32_t); 7367c478bd9Sstevel@tonic-gate break; 7377c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64: 7387c478bd9Sstevel@tonic-gate value_sz = sizeof (int64_t); 7397c478bd9Sstevel@tonic-gate break; 7407c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64: 7417c478bd9Sstevel@tonic-gate value_sz = sizeof (uint64_t); 7427c478bd9Sstevel@tonic-gate break; 7437c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING: 7447c478bd9Sstevel@tonic-gate if (data == NULL) 7457c478bd9Sstevel@tonic-gate value_sz = 0; 7467c478bd9Sstevel@tonic-gate else 7477c478bd9Sstevel@tonic-gate value_sz = strlen(data) + 1; 7487c478bd9Sstevel@tonic-gate break; 7497c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: 7507c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (boolean_t); 7517c478bd9Sstevel@tonic-gate break; 7527c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE_ARRAY: 7537c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uchar_t); 7547c478bd9Sstevel@tonic-gate break; 7557c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8_ARRAY: 7567c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (int8_t); 7577c478bd9Sstevel@tonic-gate break; 7587c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8_ARRAY: 7597c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uint8_t); 7607c478bd9Sstevel@tonic-gate break; 7617c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16_ARRAY: 7627c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (int16_t); 7637c478bd9Sstevel@tonic-gate break; 7647c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16_ARRAY: 7657c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uint16_t); 7667c478bd9Sstevel@tonic-gate break; 7677c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32_ARRAY: 7687c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (int32_t); 7697c478bd9Sstevel@tonic-gate break; 7707c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32_ARRAY: 7717c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uint32_t); 7727c478bd9Sstevel@tonic-gate break; 7737c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64_ARRAY: 7747c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (int64_t); 7757c478bd9Sstevel@tonic-gate break; 7767c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64_ARRAY: 7777c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uint64_t); 7787c478bd9Sstevel@tonic-gate break; 7797c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: 7807c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uint64_t); 7817c478bd9Sstevel@tonic-gate 7827c478bd9Sstevel@tonic-gate if (data != NULL) { 7837c478bd9Sstevel@tonic-gate char *const *strs = data; 7847c478bd9Sstevel@tonic-gate uint_t i; 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate /* no alignment requirement for strings */ 7877c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 7887c478bd9Sstevel@tonic-gate if (strs[i] == NULL) 7897c478bd9Sstevel@tonic-gate return (-1); 7907c478bd9Sstevel@tonic-gate value_sz += strlen(strs[i]) + 1; 7917c478bd9Sstevel@tonic-gate } 7927c478bd9Sstevel@tonic-gate } 7937c478bd9Sstevel@tonic-gate break; 7947c478bd9Sstevel@tonic-gate case DATA_TYPE_HRTIME: 7957c478bd9Sstevel@tonic-gate value_sz = sizeof (hrtime_t); 7967c478bd9Sstevel@tonic-gate break; 7977c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 7987c478bd9Sstevel@tonic-gate value_sz = NV_ALIGN(sizeof (nvlist_t)); 7997c478bd9Sstevel@tonic-gate break; 8007c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: 8017c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uint64_t) + 8027c478bd9Sstevel@tonic-gate (uint64_t)nelem * NV_ALIGN(sizeof (nvlist_t)); 8037c478bd9Sstevel@tonic-gate break; 8047c478bd9Sstevel@tonic-gate default: 8057c478bd9Sstevel@tonic-gate return (-1); 8067c478bd9Sstevel@tonic-gate } 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate return (value_sz > INT32_MAX ? -1 : (int)value_sz); 8097c478bd9Sstevel@tonic-gate } 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate static int 8127c478bd9Sstevel@tonic-gate nvlist_copy_embedded(nvlist_t *nvl, nvlist_t *onvl, nvlist_t *emb_nvl) 8137c478bd9Sstevel@tonic-gate { 8147c478bd9Sstevel@tonic-gate nvpriv_t *priv; 8157c478bd9Sstevel@tonic-gate int err; 8167c478bd9Sstevel@tonic-gate 8177c478bd9Sstevel@tonic-gate if ((priv = nv_priv_alloc_embedded((nvpriv_t *)(uintptr_t) 8187c478bd9Sstevel@tonic-gate nvl->nvl_priv)) == NULL) 8197c478bd9Sstevel@tonic-gate return (ENOMEM); 8207c478bd9Sstevel@tonic-gate 8217c478bd9Sstevel@tonic-gate nvlist_init(emb_nvl, onvl->nvl_nvflag, priv); 8227c478bd9Sstevel@tonic-gate 8237c478bd9Sstevel@tonic-gate if ((err = nvlist_copy_pairs(onvl, emb_nvl)) != 0) { 8247c478bd9Sstevel@tonic-gate nvlist_free(emb_nvl); 8257c478bd9Sstevel@tonic-gate emb_nvl->nvl_priv = 0; 8267c478bd9Sstevel@tonic-gate } 8277c478bd9Sstevel@tonic-gate 8287c478bd9Sstevel@tonic-gate return (err); 8297c478bd9Sstevel@tonic-gate } 8307c478bd9Sstevel@tonic-gate 8317c478bd9Sstevel@tonic-gate /* 8327c478bd9Sstevel@tonic-gate * nvlist_add_common - Add new <name,value> pair to nvlist 8337c478bd9Sstevel@tonic-gate */ 8347c478bd9Sstevel@tonic-gate static int 8357c478bd9Sstevel@tonic-gate nvlist_add_common(nvlist_t *nvl, const char *name, 8367c478bd9Sstevel@tonic-gate data_type_t type, uint_t nelem, const void *data) 8377c478bd9Sstevel@tonic-gate { 8387c478bd9Sstevel@tonic-gate nvpair_t *nvp; 839d9638e54Smws uint_t i; 840d9638e54Smws 8417c478bd9Sstevel@tonic-gate int nvp_sz, name_sz, value_sz; 8427c478bd9Sstevel@tonic-gate int err = 0; 8437c478bd9Sstevel@tonic-gate 8447c478bd9Sstevel@tonic-gate if (name == NULL || nvl == NULL || nvl->nvl_priv == 0) 8457c478bd9Sstevel@tonic-gate return (EINVAL); 8467c478bd9Sstevel@tonic-gate 8477c478bd9Sstevel@tonic-gate if (nelem != 0 && data == NULL) 8487c478bd9Sstevel@tonic-gate return (EINVAL); 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate /* 8517c478bd9Sstevel@tonic-gate * Verify type and nelem and get the value size. 8527c478bd9Sstevel@tonic-gate * In case of data types DATA_TYPE_STRING and DATA_TYPE_STRING_ARRAY 8537c478bd9Sstevel@tonic-gate * is the size of the string(s) included. 8547c478bd9Sstevel@tonic-gate */ 8557c478bd9Sstevel@tonic-gate if ((value_sz = i_get_value_size(type, data, nelem)) < 0) 8567c478bd9Sstevel@tonic-gate return (EINVAL); 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate if (i_validate_nvpair_value(type, nelem, data) != 0) 8597c478bd9Sstevel@tonic-gate return (EINVAL); 8607c478bd9Sstevel@tonic-gate 861d9638e54Smws /* 862d9638e54Smws * If we're adding an nvlist or nvlist array, ensure that we are not 863d9638e54Smws * adding the input nvlist to itself, which would cause recursion, 864d9638e54Smws * and ensure that no NULL nvlist pointers are present. 865d9638e54Smws */ 8667c478bd9Sstevel@tonic-gate switch (type) { 8677c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 868d9638e54Smws if (data == nvl || data == NULL) 8697c478bd9Sstevel@tonic-gate return (EINVAL); 8707c478bd9Sstevel@tonic-gate break; 8717c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: { 872d9638e54Smws nvlist_t **onvlp = (nvlist_t **)data; 873d9638e54Smws for (i = 0; i < nelem; i++) { 874d9638e54Smws if (onvlp[i] == nvl || onvlp[i] == NULL) 8757c478bd9Sstevel@tonic-gate return (EINVAL); 8767c478bd9Sstevel@tonic-gate } 8777c478bd9Sstevel@tonic-gate break; 878d9638e54Smws } 8795ad82045Snd default: 8805ad82045Snd break; 8817c478bd9Sstevel@tonic-gate } 8827c478bd9Sstevel@tonic-gate 8837c478bd9Sstevel@tonic-gate /* calculate sizes of the nvpair elements and the nvpair itself */ 8847c478bd9Sstevel@tonic-gate name_sz = strlen(name) + 1; 8857c478bd9Sstevel@tonic-gate 8867c478bd9Sstevel@tonic-gate nvp_sz = NVP_SIZE_CALC(name_sz, value_sz); 8877c478bd9Sstevel@tonic-gate 8887c478bd9Sstevel@tonic-gate if ((nvp = nvp_buf_alloc(nvl, nvp_sz)) == NULL) 8897c478bd9Sstevel@tonic-gate return (ENOMEM); 8907c478bd9Sstevel@tonic-gate 8917c478bd9Sstevel@tonic-gate ASSERT(nvp->nvp_size == nvp_sz); 8927c478bd9Sstevel@tonic-gate nvp->nvp_name_sz = name_sz; 8937c478bd9Sstevel@tonic-gate nvp->nvp_value_elem = nelem; 8947c478bd9Sstevel@tonic-gate nvp->nvp_type = type; 8957c478bd9Sstevel@tonic-gate bcopy(name, NVP_NAME(nvp), name_sz); 8967c478bd9Sstevel@tonic-gate 8977c478bd9Sstevel@tonic-gate switch (type) { 8987c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 8997c478bd9Sstevel@tonic-gate break; 9007c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: { 9017c478bd9Sstevel@tonic-gate char *const *strs = data; 9027c478bd9Sstevel@tonic-gate char *buf = NVP_VALUE(nvp); 9037c478bd9Sstevel@tonic-gate char **cstrs = (void *)buf; 9047c478bd9Sstevel@tonic-gate 9057c478bd9Sstevel@tonic-gate /* skip pre-allocated space for pointer array */ 9067c478bd9Sstevel@tonic-gate buf += nelem * sizeof (uint64_t); 9077c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 9087c478bd9Sstevel@tonic-gate int slen = strlen(strs[i]) + 1; 9097c478bd9Sstevel@tonic-gate bcopy(strs[i], buf, slen); 9107c478bd9Sstevel@tonic-gate cstrs[i] = buf; 9117c478bd9Sstevel@tonic-gate buf += slen; 9127c478bd9Sstevel@tonic-gate } 9137c478bd9Sstevel@tonic-gate break; 9147c478bd9Sstevel@tonic-gate } 9157c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: { 9167c478bd9Sstevel@tonic-gate nvlist_t *nnvl = EMBEDDED_NVL(nvp); 9177c478bd9Sstevel@tonic-gate nvlist_t *onvl = (nvlist_t *)data; 9187c478bd9Sstevel@tonic-gate 9197c478bd9Sstevel@tonic-gate if ((err = nvlist_copy_embedded(nvl, onvl, nnvl)) != 0) { 9207c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 9217c478bd9Sstevel@tonic-gate return (err); 9227c478bd9Sstevel@tonic-gate } 9237c478bd9Sstevel@tonic-gate break; 9247c478bd9Sstevel@tonic-gate } 9257c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: { 9267c478bd9Sstevel@tonic-gate nvlist_t **onvlp = (nvlist_t **)data; 9277c478bd9Sstevel@tonic-gate nvlist_t **nvlp = EMBEDDED_NVL_ARRAY(nvp); 9287c478bd9Sstevel@tonic-gate nvlist_t *embedded = (nvlist_t *) 9297c478bd9Sstevel@tonic-gate ((uintptr_t)nvlp + nelem * sizeof (uint64_t)); 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 9327c478bd9Sstevel@tonic-gate if ((err = nvlist_copy_embedded(nvl, 9337c478bd9Sstevel@tonic-gate onvlp[i], embedded)) != 0) { 9347c478bd9Sstevel@tonic-gate /* 9357c478bd9Sstevel@tonic-gate * Free any successfully created lists 9367c478bd9Sstevel@tonic-gate */ 9377c478bd9Sstevel@tonic-gate nvpair_free(nvp); 9387c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 9397c478bd9Sstevel@tonic-gate return (err); 9407c478bd9Sstevel@tonic-gate } 9417c478bd9Sstevel@tonic-gate 9427c478bd9Sstevel@tonic-gate nvlp[i] = embedded++; 9437c478bd9Sstevel@tonic-gate } 9447c478bd9Sstevel@tonic-gate break; 9457c478bd9Sstevel@tonic-gate } 9467c478bd9Sstevel@tonic-gate default: 9477c478bd9Sstevel@tonic-gate bcopy(data, NVP_VALUE(nvp), value_sz); 9487c478bd9Sstevel@tonic-gate } 9497c478bd9Sstevel@tonic-gate 9507c478bd9Sstevel@tonic-gate /* if unique name, remove before add */ 9517c478bd9Sstevel@tonic-gate if (nvl->nvl_nvflag & NV_UNIQUE_NAME) 9527c478bd9Sstevel@tonic-gate (void) nvlist_remove_all(nvl, name); 9537c478bd9Sstevel@tonic-gate else if (nvl->nvl_nvflag & NV_UNIQUE_NAME_TYPE) 9547c478bd9Sstevel@tonic-gate (void) nvlist_remove(nvl, name, type); 9557c478bd9Sstevel@tonic-gate 9567c478bd9Sstevel@tonic-gate nvp_buf_link(nvl, nvp); 9577c478bd9Sstevel@tonic-gate 9587c478bd9Sstevel@tonic-gate return (0); 9597c478bd9Sstevel@tonic-gate } 9607c478bd9Sstevel@tonic-gate 9617c478bd9Sstevel@tonic-gate int 9627c478bd9Sstevel@tonic-gate nvlist_add_boolean(nvlist_t *nvl, const char *name) 9637c478bd9Sstevel@tonic-gate { 9647c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN, 0, NULL)); 9657c478bd9Sstevel@tonic-gate } 9667c478bd9Sstevel@tonic-gate 9677c478bd9Sstevel@tonic-gate int 9687c478bd9Sstevel@tonic-gate nvlist_add_boolean_value(nvlist_t *nvl, const char *name, boolean_t val) 9697c478bd9Sstevel@tonic-gate { 9707c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN_VALUE, 1, &val)); 9717c478bd9Sstevel@tonic-gate } 9727c478bd9Sstevel@tonic-gate 9737c478bd9Sstevel@tonic-gate int 9747c478bd9Sstevel@tonic-gate nvlist_add_byte(nvlist_t *nvl, const char *name, uchar_t val) 9757c478bd9Sstevel@tonic-gate { 9767c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_BYTE, 1, &val)); 9777c478bd9Sstevel@tonic-gate } 9787c478bd9Sstevel@tonic-gate 9797c478bd9Sstevel@tonic-gate int 9807c478bd9Sstevel@tonic-gate nvlist_add_int8(nvlist_t *nvl, const char *name, int8_t val) 9817c478bd9Sstevel@tonic-gate { 9827c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT8, 1, &val)); 9837c478bd9Sstevel@tonic-gate } 9847c478bd9Sstevel@tonic-gate 9857c478bd9Sstevel@tonic-gate int 9867c478bd9Sstevel@tonic-gate nvlist_add_uint8(nvlist_t *nvl, const char *name, uint8_t val) 9877c478bd9Sstevel@tonic-gate { 9887c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT8, 1, &val)); 9897c478bd9Sstevel@tonic-gate } 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate int 9927c478bd9Sstevel@tonic-gate nvlist_add_int16(nvlist_t *nvl, const char *name, int16_t val) 9937c478bd9Sstevel@tonic-gate { 9947c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT16, 1, &val)); 9957c478bd9Sstevel@tonic-gate } 9967c478bd9Sstevel@tonic-gate 9977c478bd9Sstevel@tonic-gate int 9987c478bd9Sstevel@tonic-gate nvlist_add_uint16(nvlist_t *nvl, const char *name, uint16_t val) 9997c478bd9Sstevel@tonic-gate { 10007c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT16, 1, &val)); 10017c478bd9Sstevel@tonic-gate } 10027c478bd9Sstevel@tonic-gate 10037c478bd9Sstevel@tonic-gate int 10047c478bd9Sstevel@tonic-gate nvlist_add_int32(nvlist_t *nvl, const char *name, int32_t val) 10057c478bd9Sstevel@tonic-gate { 10067c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT32, 1, &val)); 10077c478bd9Sstevel@tonic-gate } 10087c478bd9Sstevel@tonic-gate 10097c478bd9Sstevel@tonic-gate int 10107c478bd9Sstevel@tonic-gate nvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val) 10117c478bd9Sstevel@tonic-gate { 10127c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT32, 1, &val)); 10137c478bd9Sstevel@tonic-gate } 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate int 10167c478bd9Sstevel@tonic-gate nvlist_add_int64(nvlist_t *nvl, const char *name, int64_t val) 10177c478bd9Sstevel@tonic-gate { 10187c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT64, 1, &val)); 10197c478bd9Sstevel@tonic-gate } 10207c478bd9Sstevel@tonic-gate 10217c478bd9Sstevel@tonic-gate int 10227c478bd9Sstevel@tonic-gate nvlist_add_uint64(nvlist_t *nvl, const char *name, uint64_t val) 10237c478bd9Sstevel@tonic-gate { 10247c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT64, 1, &val)); 10257c478bd9Sstevel@tonic-gate } 10267c478bd9Sstevel@tonic-gate 10277c478bd9Sstevel@tonic-gate int 10287c478bd9Sstevel@tonic-gate nvlist_add_string(nvlist_t *nvl, const char *name, const char *val) 10297c478bd9Sstevel@tonic-gate { 10307c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_STRING, 1, (void *)val)); 10317c478bd9Sstevel@tonic-gate } 10327c478bd9Sstevel@tonic-gate 10337c478bd9Sstevel@tonic-gate int 10347c478bd9Sstevel@tonic-gate nvlist_add_boolean_array(nvlist_t *nvl, const char *name, 10357c478bd9Sstevel@tonic-gate boolean_t *a, uint_t n) 10367c478bd9Sstevel@tonic-gate { 10377c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN_ARRAY, n, a)); 10387c478bd9Sstevel@tonic-gate } 10397c478bd9Sstevel@tonic-gate 10407c478bd9Sstevel@tonic-gate int 10417c478bd9Sstevel@tonic-gate nvlist_add_byte_array(nvlist_t *nvl, const char *name, uchar_t *a, uint_t n) 10427c478bd9Sstevel@tonic-gate { 10437c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_BYTE_ARRAY, n, a)); 10447c478bd9Sstevel@tonic-gate } 10457c478bd9Sstevel@tonic-gate 10467c478bd9Sstevel@tonic-gate int 10477c478bd9Sstevel@tonic-gate nvlist_add_int8_array(nvlist_t *nvl, const char *name, int8_t *a, uint_t n) 10487c478bd9Sstevel@tonic-gate { 10497c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT8_ARRAY, n, a)); 10507c478bd9Sstevel@tonic-gate } 10517c478bd9Sstevel@tonic-gate 10527c478bd9Sstevel@tonic-gate int 10537c478bd9Sstevel@tonic-gate nvlist_add_uint8_array(nvlist_t *nvl, const char *name, uint8_t *a, uint_t n) 10547c478bd9Sstevel@tonic-gate { 10557c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT8_ARRAY, n, a)); 10567c478bd9Sstevel@tonic-gate } 10577c478bd9Sstevel@tonic-gate 10587c478bd9Sstevel@tonic-gate int 10597c478bd9Sstevel@tonic-gate nvlist_add_int16_array(nvlist_t *nvl, const char *name, int16_t *a, uint_t n) 10607c478bd9Sstevel@tonic-gate { 10617c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT16_ARRAY, n, a)); 10627c478bd9Sstevel@tonic-gate } 10637c478bd9Sstevel@tonic-gate 10647c478bd9Sstevel@tonic-gate int 10657c478bd9Sstevel@tonic-gate nvlist_add_uint16_array(nvlist_t *nvl, const char *name, uint16_t *a, uint_t n) 10667c478bd9Sstevel@tonic-gate { 10677c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT16_ARRAY, n, a)); 10687c478bd9Sstevel@tonic-gate } 10697c478bd9Sstevel@tonic-gate 10707c478bd9Sstevel@tonic-gate int 10717c478bd9Sstevel@tonic-gate nvlist_add_int32_array(nvlist_t *nvl, const char *name, int32_t *a, uint_t n) 10727c478bd9Sstevel@tonic-gate { 10737c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT32_ARRAY, n, a)); 10747c478bd9Sstevel@tonic-gate } 10757c478bd9Sstevel@tonic-gate 10767c478bd9Sstevel@tonic-gate int 10777c478bd9Sstevel@tonic-gate nvlist_add_uint32_array(nvlist_t *nvl, const char *name, uint32_t *a, uint_t n) 10787c478bd9Sstevel@tonic-gate { 10797c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT32_ARRAY, n, a)); 10807c478bd9Sstevel@tonic-gate } 10817c478bd9Sstevel@tonic-gate 10827c478bd9Sstevel@tonic-gate int 10837c478bd9Sstevel@tonic-gate nvlist_add_int64_array(nvlist_t *nvl, const char *name, int64_t *a, uint_t n) 10847c478bd9Sstevel@tonic-gate { 10857c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT64_ARRAY, n, a)); 10867c478bd9Sstevel@tonic-gate } 10877c478bd9Sstevel@tonic-gate 10887c478bd9Sstevel@tonic-gate int 10897c478bd9Sstevel@tonic-gate nvlist_add_uint64_array(nvlist_t *nvl, const char *name, uint64_t *a, uint_t n) 10907c478bd9Sstevel@tonic-gate { 10917c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT64_ARRAY, n, a)); 10927c478bd9Sstevel@tonic-gate } 10937c478bd9Sstevel@tonic-gate 10947c478bd9Sstevel@tonic-gate int 10957c478bd9Sstevel@tonic-gate nvlist_add_string_array(nvlist_t *nvl, const char *name, 10967c478bd9Sstevel@tonic-gate char *const *a, uint_t n) 10977c478bd9Sstevel@tonic-gate { 10987c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_STRING_ARRAY, n, a)); 10997c478bd9Sstevel@tonic-gate } 11007c478bd9Sstevel@tonic-gate 11017c478bd9Sstevel@tonic-gate int 11027c478bd9Sstevel@tonic-gate nvlist_add_hrtime(nvlist_t *nvl, const char *name, hrtime_t val) 11037c478bd9Sstevel@tonic-gate { 11047c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_HRTIME, 1, &val)); 11057c478bd9Sstevel@tonic-gate } 11067c478bd9Sstevel@tonic-gate 11077c478bd9Sstevel@tonic-gate int 11087c478bd9Sstevel@tonic-gate nvlist_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val) 11097c478bd9Sstevel@tonic-gate { 11107c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_NVLIST, 1, val)); 11117c478bd9Sstevel@tonic-gate } 11127c478bd9Sstevel@tonic-gate 11137c478bd9Sstevel@tonic-gate int 11147c478bd9Sstevel@tonic-gate nvlist_add_nvlist_array(nvlist_t *nvl, const char *name, nvlist_t **a, uint_t n) 11157c478bd9Sstevel@tonic-gate { 11167c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_NVLIST_ARRAY, n, a)); 11177c478bd9Sstevel@tonic-gate } 11187c478bd9Sstevel@tonic-gate 11197c478bd9Sstevel@tonic-gate /* reading name-value pairs */ 11207c478bd9Sstevel@tonic-gate nvpair_t * 11217c478bd9Sstevel@tonic-gate nvlist_next_nvpair(nvlist_t *nvl, nvpair_t *nvp) 11227c478bd9Sstevel@tonic-gate { 11237c478bd9Sstevel@tonic-gate nvpriv_t *priv; 11247c478bd9Sstevel@tonic-gate i_nvp_t *curr; 11257c478bd9Sstevel@tonic-gate 11267c478bd9Sstevel@tonic-gate if (nvl == NULL || 11277c478bd9Sstevel@tonic-gate (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 11287c478bd9Sstevel@tonic-gate return (NULL); 11297c478bd9Sstevel@tonic-gate 11307c478bd9Sstevel@tonic-gate curr = NVPAIR2I_NVP(nvp); 11317c478bd9Sstevel@tonic-gate 11327c478bd9Sstevel@tonic-gate /* 11333cb34c60Sahrens * Ensure that nvp is a valid nvpair on this nvlist. 11343cb34c60Sahrens * NB: nvp_curr is used only as a hint so that we don't always 11353cb34c60Sahrens * have to walk the list to determine if nvp is still on the list. 11367c478bd9Sstevel@tonic-gate */ 11377c478bd9Sstevel@tonic-gate if (nvp == NULL) 11387c478bd9Sstevel@tonic-gate curr = priv->nvp_list; 11393cb34c60Sahrens else if (priv->nvp_curr == curr || nvlist_contains_nvp(nvl, nvp)) 11407c478bd9Sstevel@tonic-gate curr = curr->nvi_next; 11413cb34c60Sahrens else 11427c478bd9Sstevel@tonic-gate curr = NULL; 11437c478bd9Sstevel@tonic-gate 11447c478bd9Sstevel@tonic-gate priv->nvp_curr = curr; 11457c478bd9Sstevel@tonic-gate 11467c478bd9Sstevel@tonic-gate return (curr != NULL ? &curr->nvi_nvp : NULL); 11477c478bd9Sstevel@tonic-gate } 11487c478bd9Sstevel@tonic-gate 11497c478bd9Sstevel@tonic-gate char * 11507c478bd9Sstevel@tonic-gate nvpair_name(nvpair_t *nvp) 11517c478bd9Sstevel@tonic-gate { 11527c478bd9Sstevel@tonic-gate return (NVP_NAME(nvp)); 11537c478bd9Sstevel@tonic-gate } 11547c478bd9Sstevel@tonic-gate 11557c478bd9Sstevel@tonic-gate data_type_t 11567c478bd9Sstevel@tonic-gate nvpair_type(nvpair_t *nvp) 11577c478bd9Sstevel@tonic-gate { 11587c478bd9Sstevel@tonic-gate return (NVP_TYPE(nvp)); 11597c478bd9Sstevel@tonic-gate } 11607c478bd9Sstevel@tonic-gate 1161*602ca9eaScth int 1162*602ca9eaScth nvpair_type_is_array(nvpair_t *nvp) 1163*602ca9eaScth { 1164*602ca9eaScth data_type_t type = NVP_TYPE(nvp); 1165*602ca9eaScth 1166*602ca9eaScth if ((type == DATA_TYPE_BYTE_ARRAY) || 1167*602ca9eaScth (type == DATA_TYPE_UINT8_ARRAY) || 1168*602ca9eaScth (type == DATA_TYPE_INT16_ARRAY) || 1169*602ca9eaScth (type == DATA_TYPE_UINT16_ARRAY) || 1170*602ca9eaScth (type == DATA_TYPE_INT32_ARRAY) || 1171*602ca9eaScth (type == DATA_TYPE_UINT32_ARRAY) || 1172*602ca9eaScth (type == DATA_TYPE_INT64_ARRAY) || 1173*602ca9eaScth (type == DATA_TYPE_UINT64_ARRAY) || 1174*602ca9eaScth (type == DATA_TYPE_BOOLEAN_ARRAY) || 1175*602ca9eaScth (type == DATA_TYPE_STRING_ARRAY) || 1176*602ca9eaScth (type == DATA_TYPE_NVLIST_ARRAY)) 1177*602ca9eaScth return (1); 1178*602ca9eaScth return (0); 1179*602ca9eaScth 1180*602ca9eaScth } 1181*602ca9eaScth 11827c478bd9Sstevel@tonic-gate static int 11837c478bd9Sstevel@tonic-gate nvpair_value_common(nvpair_t *nvp, data_type_t type, uint_t *nelem, void *data) 11847c478bd9Sstevel@tonic-gate { 11857c478bd9Sstevel@tonic-gate if (nvp == NULL || nvpair_type(nvp) != type) 11867c478bd9Sstevel@tonic-gate return (EINVAL); 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate /* 11897c478bd9Sstevel@tonic-gate * For non-array types, we copy the data. 11907c478bd9Sstevel@tonic-gate * For array types (including string), we set a pointer. 11917c478bd9Sstevel@tonic-gate */ 11927c478bd9Sstevel@tonic-gate switch (type) { 11937c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 11947c478bd9Sstevel@tonic-gate if (nelem != NULL) 11957c478bd9Sstevel@tonic-gate *nelem = 0; 11967c478bd9Sstevel@tonic-gate break; 11977c478bd9Sstevel@tonic-gate 11987c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 11997c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE: 12007c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8: 12017c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8: 12027c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16: 12037c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16: 12047c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32: 12057c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32: 12067c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64: 12077c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64: 12087c478bd9Sstevel@tonic-gate case DATA_TYPE_HRTIME: 12097c478bd9Sstevel@tonic-gate if (data == NULL) 12107c478bd9Sstevel@tonic-gate return (EINVAL); 12117c478bd9Sstevel@tonic-gate bcopy(NVP_VALUE(nvp), data, 12127c478bd9Sstevel@tonic-gate (size_t)i_get_value_size(type, NULL, 1)); 12137c478bd9Sstevel@tonic-gate if (nelem != NULL) 12147c478bd9Sstevel@tonic-gate *nelem = 1; 12157c478bd9Sstevel@tonic-gate break; 12167c478bd9Sstevel@tonic-gate 12177c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 12187c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING: 12197c478bd9Sstevel@tonic-gate if (data == NULL) 12207c478bd9Sstevel@tonic-gate return (EINVAL); 12217c478bd9Sstevel@tonic-gate *(void **)data = (void *)NVP_VALUE(nvp); 12227c478bd9Sstevel@tonic-gate if (nelem != NULL) 12237c478bd9Sstevel@tonic-gate *nelem = 1; 12247c478bd9Sstevel@tonic-gate break; 12257c478bd9Sstevel@tonic-gate 12267c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: 12277c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE_ARRAY: 12287c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8_ARRAY: 12297c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8_ARRAY: 12307c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16_ARRAY: 12317c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16_ARRAY: 12327c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32_ARRAY: 12337c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32_ARRAY: 12347c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64_ARRAY: 12357c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64_ARRAY: 12367c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: 12377c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: 12387c478bd9Sstevel@tonic-gate if (nelem == NULL || data == NULL) 12397c478bd9Sstevel@tonic-gate return (EINVAL); 12407c478bd9Sstevel@tonic-gate if ((*nelem = NVP_NELEM(nvp)) != 0) 12417c478bd9Sstevel@tonic-gate *(void **)data = (void *)NVP_VALUE(nvp); 12427c478bd9Sstevel@tonic-gate else 12437c478bd9Sstevel@tonic-gate *(void **)data = NULL; 12447c478bd9Sstevel@tonic-gate break; 12457c478bd9Sstevel@tonic-gate 12467c478bd9Sstevel@tonic-gate default: 12477c478bd9Sstevel@tonic-gate return (ENOTSUP); 12487c478bd9Sstevel@tonic-gate } 12497c478bd9Sstevel@tonic-gate 12507c478bd9Sstevel@tonic-gate return (0); 12517c478bd9Sstevel@tonic-gate } 12527c478bd9Sstevel@tonic-gate 12537c478bd9Sstevel@tonic-gate static int 12547c478bd9Sstevel@tonic-gate nvlist_lookup_common(nvlist_t *nvl, const char *name, data_type_t type, 12557c478bd9Sstevel@tonic-gate uint_t *nelem, void *data) 12567c478bd9Sstevel@tonic-gate { 12577c478bd9Sstevel@tonic-gate nvpriv_t *priv; 12587c478bd9Sstevel@tonic-gate nvpair_t *nvp; 12597c478bd9Sstevel@tonic-gate i_nvp_t *curr; 12607c478bd9Sstevel@tonic-gate 12617c478bd9Sstevel@tonic-gate if (name == NULL || nvl == NULL || 12627c478bd9Sstevel@tonic-gate (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 12637c478bd9Sstevel@tonic-gate return (EINVAL); 12647c478bd9Sstevel@tonic-gate 12657c478bd9Sstevel@tonic-gate if (!(nvl->nvl_nvflag & (NV_UNIQUE_NAME | NV_UNIQUE_NAME_TYPE))) 12667c478bd9Sstevel@tonic-gate return (ENOTSUP); 12677c478bd9Sstevel@tonic-gate 12687c478bd9Sstevel@tonic-gate for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) { 12697c478bd9Sstevel@tonic-gate nvp = &curr->nvi_nvp; 12707c478bd9Sstevel@tonic-gate 12717c478bd9Sstevel@tonic-gate if (strcmp(name, NVP_NAME(nvp)) == 0 && NVP_TYPE(nvp) == type) 12727c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, type, nelem, data)); 12737c478bd9Sstevel@tonic-gate } 12747c478bd9Sstevel@tonic-gate 12757c478bd9Sstevel@tonic-gate return (ENOENT); 12767c478bd9Sstevel@tonic-gate } 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate int 12797c478bd9Sstevel@tonic-gate nvlist_lookup_boolean(nvlist_t *nvl, const char *name) 12807c478bd9Sstevel@tonic-gate { 12817c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_BOOLEAN, NULL, NULL)); 12827c478bd9Sstevel@tonic-gate } 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate int 12857c478bd9Sstevel@tonic-gate nvlist_lookup_boolean_value(nvlist_t *nvl, const char *name, boolean_t *val) 12867c478bd9Sstevel@tonic-gate { 12877c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, 12887c478bd9Sstevel@tonic-gate DATA_TYPE_BOOLEAN_VALUE, NULL, val)); 12897c478bd9Sstevel@tonic-gate } 12907c478bd9Sstevel@tonic-gate 12917c478bd9Sstevel@tonic-gate int 12927c478bd9Sstevel@tonic-gate nvlist_lookup_byte(nvlist_t *nvl, const char *name, uchar_t *val) 12937c478bd9Sstevel@tonic-gate { 12947c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_BYTE, NULL, val)); 12957c478bd9Sstevel@tonic-gate } 12967c478bd9Sstevel@tonic-gate 12977c478bd9Sstevel@tonic-gate int 12987c478bd9Sstevel@tonic-gate nvlist_lookup_int8(nvlist_t *nvl, const char *name, int8_t *val) 12997c478bd9Sstevel@tonic-gate { 13007c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT8, NULL, val)); 13017c478bd9Sstevel@tonic-gate } 13027c478bd9Sstevel@tonic-gate 13037c478bd9Sstevel@tonic-gate int 13047c478bd9Sstevel@tonic-gate nvlist_lookup_uint8(nvlist_t *nvl, const char *name, uint8_t *val) 13057c478bd9Sstevel@tonic-gate { 13067c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT8, NULL, val)); 13077c478bd9Sstevel@tonic-gate } 13087c478bd9Sstevel@tonic-gate 13097c478bd9Sstevel@tonic-gate int 13107c478bd9Sstevel@tonic-gate nvlist_lookup_int16(nvlist_t *nvl, const char *name, int16_t *val) 13117c478bd9Sstevel@tonic-gate { 13127c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT16, NULL, val)); 13137c478bd9Sstevel@tonic-gate } 13147c478bd9Sstevel@tonic-gate 13157c478bd9Sstevel@tonic-gate int 13167c478bd9Sstevel@tonic-gate nvlist_lookup_uint16(nvlist_t *nvl, const char *name, uint16_t *val) 13177c478bd9Sstevel@tonic-gate { 13187c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT16, NULL, val)); 13197c478bd9Sstevel@tonic-gate } 13207c478bd9Sstevel@tonic-gate 13217c478bd9Sstevel@tonic-gate int 13227c478bd9Sstevel@tonic-gate nvlist_lookup_int32(nvlist_t *nvl, const char *name, int32_t *val) 13237c478bd9Sstevel@tonic-gate { 13247c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT32, NULL, val)); 13257c478bd9Sstevel@tonic-gate } 13267c478bd9Sstevel@tonic-gate 13277c478bd9Sstevel@tonic-gate int 13287c478bd9Sstevel@tonic-gate nvlist_lookup_uint32(nvlist_t *nvl, const char *name, uint32_t *val) 13297c478bd9Sstevel@tonic-gate { 13307c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT32, NULL, val)); 13317c478bd9Sstevel@tonic-gate } 13327c478bd9Sstevel@tonic-gate 13337c478bd9Sstevel@tonic-gate int 13347c478bd9Sstevel@tonic-gate nvlist_lookup_int64(nvlist_t *nvl, const char *name, int64_t *val) 13357c478bd9Sstevel@tonic-gate { 13367c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT64, NULL, val)); 13377c478bd9Sstevel@tonic-gate } 13387c478bd9Sstevel@tonic-gate 13397c478bd9Sstevel@tonic-gate int 13407c478bd9Sstevel@tonic-gate nvlist_lookup_uint64(nvlist_t *nvl, const char *name, uint64_t *val) 13417c478bd9Sstevel@tonic-gate { 13427c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT64, NULL, val)); 13437c478bd9Sstevel@tonic-gate } 13447c478bd9Sstevel@tonic-gate 13457c478bd9Sstevel@tonic-gate int 13467c478bd9Sstevel@tonic-gate nvlist_lookup_string(nvlist_t *nvl, const char *name, char **val) 13477c478bd9Sstevel@tonic-gate { 13487c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_STRING, NULL, val)); 13497c478bd9Sstevel@tonic-gate } 13507c478bd9Sstevel@tonic-gate 13517c478bd9Sstevel@tonic-gate int 13527c478bd9Sstevel@tonic-gate nvlist_lookup_nvlist(nvlist_t *nvl, const char *name, nvlist_t **val) 13537c478bd9Sstevel@tonic-gate { 13547c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_NVLIST, NULL, val)); 13557c478bd9Sstevel@tonic-gate } 13567c478bd9Sstevel@tonic-gate 13577c478bd9Sstevel@tonic-gate int 13587c478bd9Sstevel@tonic-gate nvlist_lookup_boolean_array(nvlist_t *nvl, const char *name, 13597c478bd9Sstevel@tonic-gate boolean_t **a, uint_t *n) 13607c478bd9Sstevel@tonic-gate { 13617c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, 13627c478bd9Sstevel@tonic-gate DATA_TYPE_BOOLEAN_ARRAY, n, a)); 13637c478bd9Sstevel@tonic-gate } 13647c478bd9Sstevel@tonic-gate 13657c478bd9Sstevel@tonic-gate int 13667c478bd9Sstevel@tonic-gate nvlist_lookup_byte_array(nvlist_t *nvl, const char *name, 13677c478bd9Sstevel@tonic-gate uchar_t **a, uint_t *n) 13687c478bd9Sstevel@tonic-gate { 13697c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_BYTE_ARRAY, n, a)); 13707c478bd9Sstevel@tonic-gate } 13717c478bd9Sstevel@tonic-gate 13727c478bd9Sstevel@tonic-gate int 13737c478bd9Sstevel@tonic-gate nvlist_lookup_int8_array(nvlist_t *nvl, const char *name, int8_t **a, uint_t *n) 13747c478bd9Sstevel@tonic-gate { 13757c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT8_ARRAY, n, a)); 13767c478bd9Sstevel@tonic-gate } 13777c478bd9Sstevel@tonic-gate 13787c478bd9Sstevel@tonic-gate int 13797c478bd9Sstevel@tonic-gate nvlist_lookup_uint8_array(nvlist_t *nvl, const char *name, 13807c478bd9Sstevel@tonic-gate uint8_t **a, uint_t *n) 13817c478bd9Sstevel@tonic-gate { 13827c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT8_ARRAY, n, a)); 13837c478bd9Sstevel@tonic-gate } 13847c478bd9Sstevel@tonic-gate 13857c478bd9Sstevel@tonic-gate int 13867c478bd9Sstevel@tonic-gate nvlist_lookup_int16_array(nvlist_t *nvl, const char *name, 13877c478bd9Sstevel@tonic-gate int16_t **a, uint_t *n) 13887c478bd9Sstevel@tonic-gate { 13897c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT16_ARRAY, n, a)); 13907c478bd9Sstevel@tonic-gate } 13917c478bd9Sstevel@tonic-gate 13927c478bd9Sstevel@tonic-gate int 13937c478bd9Sstevel@tonic-gate nvlist_lookup_uint16_array(nvlist_t *nvl, const char *name, 13947c478bd9Sstevel@tonic-gate uint16_t **a, uint_t *n) 13957c478bd9Sstevel@tonic-gate { 13967c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT16_ARRAY, n, a)); 13977c478bd9Sstevel@tonic-gate } 13987c478bd9Sstevel@tonic-gate 13997c478bd9Sstevel@tonic-gate int 14007c478bd9Sstevel@tonic-gate nvlist_lookup_int32_array(nvlist_t *nvl, const char *name, 14017c478bd9Sstevel@tonic-gate int32_t **a, uint_t *n) 14027c478bd9Sstevel@tonic-gate { 14037c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT32_ARRAY, n, a)); 14047c478bd9Sstevel@tonic-gate } 14057c478bd9Sstevel@tonic-gate 14067c478bd9Sstevel@tonic-gate int 14077c478bd9Sstevel@tonic-gate nvlist_lookup_uint32_array(nvlist_t *nvl, const char *name, 14087c478bd9Sstevel@tonic-gate uint32_t **a, uint_t *n) 14097c478bd9Sstevel@tonic-gate { 14107c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT32_ARRAY, n, a)); 14117c478bd9Sstevel@tonic-gate } 14127c478bd9Sstevel@tonic-gate 14137c478bd9Sstevel@tonic-gate int 14147c478bd9Sstevel@tonic-gate nvlist_lookup_int64_array(nvlist_t *nvl, const char *name, 14157c478bd9Sstevel@tonic-gate int64_t **a, uint_t *n) 14167c478bd9Sstevel@tonic-gate { 14177c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT64_ARRAY, n, a)); 14187c478bd9Sstevel@tonic-gate } 14197c478bd9Sstevel@tonic-gate 14207c478bd9Sstevel@tonic-gate int 14217c478bd9Sstevel@tonic-gate nvlist_lookup_uint64_array(nvlist_t *nvl, const char *name, 14227c478bd9Sstevel@tonic-gate uint64_t **a, uint_t *n) 14237c478bd9Sstevel@tonic-gate { 14247c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT64_ARRAY, n, a)); 14257c478bd9Sstevel@tonic-gate } 14267c478bd9Sstevel@tonic-gate 14277c478bd9Sstevel@tonic-gate int 14287c478bd9Sstevel@tonic-gate nvlist_lookup_string_array(nvlist_t *nvl, const char *name, 14297c478bd9Sstevel@tonic-gate char ***a, uint_t *n) 14307c478bd9Sstevel@tonic-gate { 14317c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_STRING_ARRAY, n, a)); 14327c478bd9Sstevel@tonic-gate } 14337c478bd9Sstevel@tonic-gate 14347c478bd9Sstevel@tonic-gate int 14357c478bd9Sstevel@tonic-gate nvlist_lookup_nvlist_array(nvlist_t *nvl, const char *name, 14367c478bd9Sstevel@tonic-gate nvlist_t ***a, uint_t *n) 14377c478bd9Sstevel@tonic-gate { 14387c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_NVLIST_ARRAY, n, a)); 14397c478bd9Sstevel@tonic-gate } 14407c478bd9Sstevel@tonic-gate 14417c478bd9Sstevel@tonic-gate int 14427c478bd9Sstevel@tonic-gate nvlist_lookup_hrtime(nvlist_t *nvl, const char *name, hrtime_t *val) 14437c478bd9Sstevel@tonic-gate { 14447c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_HRTIME, NULL, val)); 14457c478bd9Sstevel@tonic-gate } 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate int 14487c478bd9Sstevel@tonic-gate nvlist_lookup_pairs(nvlist_t *nvl, int flag, ...) 14497c478bd9Sstevel@tonic-gate { 14507c478bd9Sstevel@tonic-gate va_list ap; 14517c478bd9Sstevel@tonic-gate char *name; 14527c478bd9Sstevel@tonic-gate int noentok = (flag & NV_FLAG_NOENTOK ? 1 : 0); 14537c478bd9Sstevel@tonic-gate int ret = 0; 14547c478bd9Sstevel@tonic-gate 14557c478bd9Sstevel@tonic-gate va_start(ap, flag); 14567c478bd9Sstevel@tonic-gate while (ret == 0 && (name = va_arg(ap, char *)) != NULL) { 14577c478bd9Sstevel@tonic-gate data_type_t type; 14587c478bd9Sstevel@tonic-gate void *val; 14597c478bd9Sstevel@tonic-gate uint_t *nelem; 14607c478bd9Sstevel@tonic-gate 14617c478bd9Sstevel@tonic-gate switch (type = va_arg(ap, data_type_t)) { 14627c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 14637c478bd9Sstevel@tonic-gate ret = nvlist_lookup_common(nvl, name, type, NULL, NULL); 14647c478bd9Sstevel@tonic-gate break; 14657c478bd9Sstevel@tonic-gate 14667c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 14677c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE: 14687c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8: 14697c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8: 14707c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16: 14717c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16: 14727c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32: 14737c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32: 14747c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64: 14757c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64: 14767c478bd9Sstevel@tonic-gate case DATA_TYPE_HRTIME: 14777c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING: 14787c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 14797c478bd9Sstevel@tonic-gate val = va_arg(ap, void *); 14807c478bd9Sstevel@tonic-gate ret = nvlist_lookup_common(nvl, name, type, NULL, val); 14817c478bd9Sstevel@tonic-gate break; 14827c478bd9Sstevel@tonic-gate 14837c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE_ARRAY: 14847c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: 14857c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8_ARRAY: 14867c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8_ARRAY: 14877c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16_ARRAY: 14887c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16_ARRAY: 14897c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32_ARRAY: 14907c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32_ARRAY: 14917c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64_ARRAY: 14927c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64_ARRAY: 14937c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: 14947c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: 14957c478bd9Sstevel@tonic-gate val = va_arg(ap, void *); 14967c478bd9Sstevel@tonic-gate nelem = va_arg(ap, uint_t *); 14977c478bd9Sstevel@tonic-gate ret = nvlist_lookup_common(nvl, name, type, nelem, val); 14987c478bd9Sstevel@tonic-gate break; 14997c478bd9Sstevel@tonic-gate 15007c478bd9Sstevel@tonic-gate default: 15017c478bd9Sstevel@tonic-gate ret = EINVAL; 15027c478bd9Sstevel@tonic-gate } 15037c478bd9Sstevel@tonic-gate 15047c478bd9Sstevel@tonic-gate if (ret == ENOENT && noentok) 15057c478bd9Sstevel@tonic-gate ret = 0; 15067c478bd9Sstevel@tonic-gate } 15077c478bd9Sstevel@tonic-gate va_end(ap); 15087c478bd9Sstevel@tonic-gate 15097c478bd9Sstevel@tonic-gate return (ret); 15107c478bd9Sstevel@tonic-gate } 15117c478bd9Sstevel@tonic-gate 1512*602ca9eaScth /* 1513*602ca9eaScth * Find the 'name'ed nvpair in the nvlist 'nvl'. If 'name' found, the function 1514*602ca9eaScth * returns zero and a pointer to the matching nvpair is returned in '*ret' 1515*602ca9eaScth * (given 'ret' is non-NULL). If 'sep' is specified then 'name' will penitrate 1516*602ca9eaScth * multiple levels of embedded nvlists, with 'sep' as the separator. As an 1517*602ca9eaScth * example, if sep is '.', name might look like: "a" or "a.b" or "a.c[3]" or 1518*602ca9eaScth * "a.d[3].e[1]". This matches the C syntax for array embed (for convience, 1519*602ca9eaScth * code also supports "a.d[3]e[1]" syntax). 1520*602ca9eaScth * 1521*602ca9eaScth * If 'ip' is non-NULL and the last name component is an array, return the 1522*602ca9eaScth * value of the "...[index]" array index in *ip. For an array reference that 1523*602ca9eaScth * is not indexed, *ip will be returned as -1. If there is a syntax error in 1524*602ca9eaScth * 'name', and 'ep' is non-NULL then *ep will be set to point to the location 1525*602ca9eaScth * inside the 'name' string where the syntax error was detected. 1526*602ca9eaScth */ 1527*602ca9eaScth static int 1528*602ca9eaScth nvlist_lookup_nvpair_ei_sep(nvlist_t *nvl, const char *name, const char sep, 1529*602ca9eaScth nvpair_t **ret, int *ip, char **ep) 1530*602ca9eaScth { 1531*602ca9eaScth nvpair_t *nvp; 1532*602ca9eaScth const char *np; 1533*602ca9eaScth char *sepp; 1534*602ca9eaScth char *idxp, *idxep; 1535*602ca9eaScth nvlist_t **nva; 1536*602ca9eaScth long idx; 1537*602ca9eaScth int n; 1538*602ca9eaScth 1539*602ca9eaScth if (ip) 1540*602ca9eaScth *ip = -1; /* not indexed */ 1541*602ca9eaScth if (ep) 1542*602ca9eaScth *ep = NULL; 1543*602ca9eaScth 1544*602ca9eaScth if ((nvl == NULL) || (name == NULL)) 15451af98250Seschrock return (EINVAL); 15461af98250Seschrock 1547*602ca9eaScth /* step through components of name */ 1548*602ca9eaScth for (np = name; np && *np; np = sepp) { 1549*602ca9eaScth /* ensure unique names */ 1550*602ca9eaScth if (!(nvl->nvl_nvflag & NV_UNIQUE_NAME)) 1551*602ca9eaScth return (ENOTSUP); 15521af98250Seschrock 1553*602ca9eaScth /* skip white space */ 1554*602ca9eaScth skip_whitespace(np); 1555*602ca9eaScth if (*np == 0) 1556*602ca9eaScth break; 15571af98250Seschrock 1558*602ca9eaScth /* set 'sepp' to end of current component 'np' */ 1559*602ca9eaScth if (sep) 1560*602ca9eaScth sepp = strchr(np, sep); 1561*602ca9eaScth else 1562*602ca9eaScth sepp = NULL; 1563*602ca9eaScth 1564*602ca9eaScth /* find start of next "[ index ]..." */ 1565*602ca9eaScth idxp = strchr(np, '['); 1566*602ca9eaScth 1567*602ca9eaScth /* if sepp comes first, set idxp to NULL */ 1568*602ca9eaScth if (sepp && idxp && (sepp < idxp)) 1569*602ca9eaScth idxp = NULL; 1570*602ca9eaScth 1571*602ca9eaScth /* 1572*602ca9eaScth * At this point 'idxp' is set if there is an index 1573*602ca9eaScth * expected for the current component. 1574*602ca9eaScth */ 1575*602ca9eaScth if (idxp) { 1576*602ca9eaScth /* set 'n' to length of current 'np' name component */ 1577*602ca9eaScth n = idxp++ - np; 1578*602ca9eaScth 1579*602ca9eaScth /* keep sepp up to date for *ep use as we advance */ 1580*602ca9eaScth skip_whitespace(idxp); 1581*602ca9eaScth sepp = idxp; 1582*602ca9eaScth 1583*602ca9eaScth /* determine the index value */ 1584*602ca9eaScth #if defined(_KERNEL) && !defined(_BOOT) 1585*602ca9eaScth if (ddi_strtol(idxp, &idxep, 0, &idx)) 1586*602ca9eaScth goto fail; 1587*602ca9eaScth #else 1588*602ca9eaScth idx = strtol(idxp, &idxep, 0); 1589*602ca9eaScth #endif 1590*602ca9eaScth if (idxep == idxp) 1591*602ca9eaScth goto fail; 1592*602ca9eaScth 1593*602ca9eaScth /* keep sepp up to date for *ep use as we advance */ 1594*602ca9eaScth sepp = idxep; 1595*602ca9eaScth 1596*602ca9eaScth /* skip white space index value and check for ']' */ 1597*602ca9eaScth skip_whitespace(sepp); 1598*602ca9eaScth if (*sepp++ != ']') 1599*602ca9eaScth goto fail; 1600*602ca9eaScth 1601*602ca9eaScth /* for embedded arrays, support C syntax: "a[1].b" */ 1602*602ca9eaScth skip_whitespace(sepp); 1603*602ca9eaScth if (sep && (*sepp == sep)) 1604*602ca9eaScth sepp++; 1605*602ca9eaScth } else if (sepp) { 1606*602ca9eaScth n = sepp++ - np; 1607*602ca9eaScth } else { 1608*602ca9eaScth n = strlen(np); 1609*602ca9eaScth } 1610*602ca9eaScth 1611*602ca9eaScth /* trim trailing whitespace by reducing length of 'np' */ 1612*602ca9eaScth if (n == 0) 1613*602ca9eaScth goto fail; 1614*602ca9eaScth for (n--; (np[n] == ' ') || (np[n] == '\t'); n--) 1615*602ca9eaScth ; 1616*602ca9eaScth n++; 1617*602ca9eaScth 1618*602ca9eaScth /* skip whitespace, and set sepp to NULL if complete */ 1619*602ca9eaScth if (sepp) { 1620*602ca9eaScth skip_whitespace(sepp); 1621*602ca9eaScth if (*sepp == 0) 1622*602ca9eaScth sepp = NULL; 1623*602ca9eaScth } 1624*602ca9eaScth 1625*602ca9eaScth /* 1626*602ca9eaScth * At this point: 1627*602ca9eaScth * o 'n' is the length of current 'np' component. 1628*602ca9eaScth * o 'idxp' is set if there was an index, and value 'idx'. 1629*602ca9eaScth * o 'sepp' is set to the beginning of the next component, 1630*602ca9eaScth * and set to NULL if we have no more components. 1631*602ca9eaScth * 1632*602ca9eaScth * Search for nvpair with matching component name. 1633*602ca9eaScth */ 1634*602ca9eaScth for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL; 1635*602ca9eaScth nvp = nvlist_next_nvpair(nvl, nvp)) { 1636*602ca9eaScth 1637*602ca9eaScth /* continue if no match on name */ 1638*602ca9eaScth if (strncmp(np, nvpair_name(nvp), n) || 1639*602ca9eaScth (strlen(nvpair_name(nvp)) != n)) 1640*602ca9eaScth continue; 1641*602ca9eaScth 1642*602ca9eaScth /* if indexed, verify type is array oriented */ 1643*602ca9eaScth if (idxp && !nvpair_type_is_array(nvp)) 1644*602ca9eaScth goto fail; 1645*602ca9eaScth 1646*602ca9eaScth /* 1647*602ca9eaScth * Full match found, return nvp and idx if this 1648*602ca9eaScth * was the last component. 1649*602ca9eaScth */ 1650*602ca9eaScth if (sepp == NULL) { 1651*602ca9eaScth if (ret) 1652*602ca9eaScth *ret = nvp; 1653*602ca9eaScth if (ip && idxp) 1654*602ca9eaScth *ip = (int)idx; /* return index */ 1655*602ca9eaScth return (0); /* found */ 1656*602ca9eaScth } 1657*602ca9eaScth 1658*602ca9eaScth /* 1659*602ca9eaScth * More components: current match must be 1660*602ca9eaScth * of DATA_TYPE_NVLIST or DATA_TYPE_NVLIST_ARRAY 1661*602ca9eaScth * to support going deeper. 1662*602ca9eaScth */ 1663*602ca9eaScth if (nvpair_type(nvp) == DATA_TYPE_NVLIST) { 1664*602ca9eaScth nvl = EMBEDDED_NVL(nvp); 1665*602ca9eaScth break; 1666*602ca9eaScth } else if (nvpair_type(nvp) == DATA_TYPE_NVLIST_ARRAY) { 1667*602ca9eaScth (void) nvpair_value_nvlist_array(nvp, 1668*602ca9eaScth &nva, (uint_t *)&n); 1669*602ca9eaScth if ((n < 0) || (idx >= n)) 1670*602ca9eaScth goto fail; 1671*602ca9eaScth nvl = nva[idx]; 1672*602ca9eaScth break; 1673*602ca9eaScth } 1674*602ca9eaScth 1675*602ca9eaScth /* type does not support more levels */ 1676*602ca9eaScth goto fail; 16771af98250Seschrock } 1678*602ca9eaScth if (nvp == NULL) 1679*602ca9eaScth goto fail; /* 'name' not found */ 1680*602ca9eaScth 1681*602ca9eaScth /* search for match of next component in embedded 'nvl' list */ 16821af98250Seschrock } 16831af98250Seschrock 1684*602ca9eaScth fail: if (ep && sepp) 1685*602ca9eaScth *ep = sepp; 1686*602ca9eaScth return (EINVAL); 1687*602ca9eaScth } 1688*602ca9eaScth 1689*602ca9eaScth /* 1690*602ca9eaScth * Return pointer to nvpair with specified 'name'. 1691*602ca9eaScth */ 1692*602ca9eaScth int 1693*602ca9eaScth nvlist_lookup_nvpair(nvlist_t *nvl, const char *name, nvpair_t **ret) 1694*602ca9eaScth { 1695*602ca9eaScth return (nvlist_lookup_nvpair_ei_sep(nvl, name, 0, ret, NULL, NULL)); 1696*602ca9eaScth } 1697*602ca9eaScth 1698*602ca9eaScth /* 1699*602ca9eaScth * Determine if named nvpair exists in nvlist (use embedded separator of '.' 1700*602ca9eaScth * and return array index). See nvlist_lookup_nvpair_ei_sep for more detailed 1701*602ca9eaScth * description. 1702*602ca9eaScth */ 1703*602ca9eaScth int nvlist_lookup_nvpair_embedded_index(nvlist_t *nvl, 1704*602ca9eaScth const char *name, nvpair_t **ret, int *ip, char **ep) 1705*602ca9eaScth { 1706*602ca9eaScth return (nvlist_lookup_nvpair_ei_sep(nvl, name, '.', ret, ip, ep)); 17071af98250Seschrock } 17081af98250Seschrock 17091af98250Seschrock boolean_t 17101af98250Seschrock nvlist_exists(nvlist_t *nvl, const char *name) 17111af98250Seschrock { 17121af98250Seschrock nvpriv_t *priv; 17131af98250Seschrock nvpair_t *nvp; 17141af98250Seschrock i_nvp_t *curr; 17151af98250Seschrock 17161af98250Seschrock if (name == NULL || nvl == NULL || 17171af98250Seschrock (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 17181af98250Seschrock return (B_FALSE); 17191af98250Seschrock 17201af98250Seschrock for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) { 17211af98250Seschrock nvp = &curr->nvi_nvp; 17221af98250Seschrock 17231af98250Seschrock if (strcmp(name, NVP_NAME(nvp)) == 0) 17241af98250Seschrock return (B_TRUE); 17251af98250Seschrock } 17261af98250Seschrock 17271af98250Seschrock return (B_FALSE); 17281af98250Seschrock } 17291af98250Seschrock 17307c478bd9Sstevel@tonic-gate int 17317c478bd9Sstevel@tonic-gate nvpair_value_boolean_value(nvpair_t *nvp, boolean_t *val) 17327c478bd9Sstevel@tonic-gate { 17337c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_BOOLEAN_VALUE, NULL, val)); 17347c478bd9Sstevel@tonic-gate } 17357c478bd9Sstevel@tonic-gate 17367c478bd9Sstevel@tonic-gate int 17377c478bd9Sstevel@tonic-gate nvpair_value_byte(nvpair_t *nvp, uchar_t *val) 17387c478bd9Sstevel@tonic-gate { 17397c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_BYTE, NULL, val)); 17407c478bd9Sstevel@tonic-gate } 17417c478bd9Sstevel@tonic-gate 17427c478bd9Sstevel@tonic-gate int 17437c478bd9Sstevel@tonic-gate nvpair_value_int8(nvpair_t *nvp, int8_t *val) 17447c478bd9Sstevel@tonic-gate { 17457c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT8, NULL, val)); 17467c478bd9Sstevel@tonic-gate } 17477c478bd9Sstevel@tonic-gate 17487c478bd9Sstevel@tonic-gate int 17497c478bd9Sstevel@tonic-gate nvpair_value_uint8(nvpair_t *nvp, uint8_t *val) 17507c478bd9Sstevel@tonic-gate { 17517c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT8, NULL, val)); 17527c478bd9Sstevel@tonic-gate } 17537c478bd9Sstevel@tonic-gate 17547c478bd9Sstevel@tonic-gate int 17557c478bd9Sstevel@tonic-gate nvpair_value_int16(nvpair_t *nvp, int16_t *val) 17567c478bd9Sstevel@tonic-gate { 17577c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT16, NULL, val)); 17587c478bd9Sstevel@tonic-gate } 17597c478bd9Sstevel@tonic-gate 17607c478bd9Sstevel@tonic-gate int 17617c478bd9Sstevel@tonic-gate nvpair_value_uint16(nvpair_t *nvp, uint16_t *val) 17627c478bd9Sstevel@tonic-gate { 17637c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT16, NULL, val)); 17647c478bd9Sstevel@tonic-gate } 17657c478bd9Sstevel@tonic-gate 17667c478bd9Sstevel@tonic-gate int 17677c478bd9Sstevel@tonic-gate nvpair_value_int32(nvpair_t *nvp, int32_t *val) 17687c478bd9Sstevel@tonic-gate { 17697c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT32, NULL, val)); 17707c478bd9Sstevel@tonic-gate } 17717c478bd9Sstevel@tonic-gate 17727c478bd9Sstevel@tonic-gate int 17737c478bd9Sstevel@tonic-gate nvpair_value_uint32(nvpair_t *nvp, uint32_t *val) 17747c478bd9Sstevel@tonic-gate { 17757c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT32, NULL, val)); 17767c478bd9Sstevel@tonic-gate } 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate int 17797c478bd9Sstevel@tonic-gate nvpair_value_int64(nvpair_t *nvp, int64_t *val) 17807c478bd9Sstevel@tonic-gate { 17817c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT64, NULL, val)); 17827c478bd9Sstevel@tonic-gate } 17837c478bd9Sstevel@tonic-gate 17847c478bd9Sstevel@tonic-gate int 17857c478bd9Sstevel@tonic-gate nvpair_value_uint64(nvpair_t *nvp, uint64_t *val) 17867c478bd9Sstevel@tonic-gate { 17877c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT64, NULL, val)); 17887c478bd9Sstevel@tonic-gate } 17897c478bd9Sstevel@tonic-gate 17907c478bd9Sstevel@tonic-gate int 17917c478bd9Sstevel@tonic-gate nvpair_value_string(nvpair_t *nvp, char **val) 17927c478bd9Sstevel@tonic-gate { 17937c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_STRING, NULL, val)); 17947c478bd9Sstevel@tonic-gate } 17957c478bd9Sstevel@tonic-gate 17967c478bd9Sstevel@tonic-gate int 17977c478bd9Sstevel@tonic-gate nvpair_value_nvlist(nvpair_t *nvp, nvlist_t **val) 17987c478bd9Sstevel@tonic-gate { 17997c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_NVLIST, NULL, val)); 18007c478bd9Sstevel@tonic-gate } 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate int 18037c478bd9Sstevel@tonic-gate nvpair_value_boolean_array(nvpair_t *nvp, boolean_t **val, uint_t *nelem) 18047c478bd9Sstevel@tonic-gate { 18057c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_BOOLEAN_ARRAY, nelem, val)); 18067c478bd9Sstevel@tonic-gate } 18077c478bd9Sstevel@tonic-gate 18087c478bd9Sstevel@tonic-gate int 18097c478bd9Sstevel@tonic-gate nvpair_value_byte_array(nvpair_t *nvp, uchar_t **val, uint_t *nelem) 18107c478bd9Sstevel@tonic-gate { 18117c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_BYTE_ARRAY, nelem, val)); 18127c478bd9Sstevel@tonic-gate } 18137c478bd9Sstevel@tonic-gate 18147c478bd9Sstevel@tonic-gate int 18157c478bd9Sstevel@tonic-gate nvpair_value_int8_array(nvpair_t *nvp, int8_t **val, uint_t *nelem) 18167c478bd9Sstevel@tonic-gate { 18177c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT8_ARRAY, nelem, val)); 18187c478bd9Sstevel@tonic-gate } 18197c478bd9Sstevel@tonic-gate 18207c478bd9Sstevel@tonic-gate int 18217c478bd9Sstevel@tonic-gate nvpair_value_uint8_array(nvpair_t *nvp, uint8_t **val, uint_t *nelem) 18227c478bd9Sstevel@tonic-gate { 18237c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT8_ARRAY, nelem, val)); 18247c478bd9Sstevel@tonic-gate } 18257c478bd9Sstevel@tonic-gate 18267c478bd9Sstevel@tonic-gate int 18277c478bd9Sstevel@tonic-gate nvpair_value_int16_array(nvpair_t *nvp, int16_t **val, uint_t *nelem) 18287c478bd9Sstevel@tonic-gate { 18297c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT16_ARRAY, nelem, val)); 18307c478bd9Sstevel@tonic-gate } 18317c478bd9Sstevel@tonic-gate 18327c478bd9Sstevel@tonic-gate int 18337c478bd9Sstevel@tonic-gate nvpair_value_uint16_array(nvpair_t *nvp, uint16_t **val, uint_t *nelem) 18347c478bd9Sstevel@tonic-gate { 18357c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT16_ARRAY, nelem, val)); 18367c478bd9Sstevel@tonic-gate } 18377c478bd9Sstevel@tonic-gate 18387c478bd9Sstevel@tonic-gate int 18397c478bd9Sstevel@tonic-gate nvpair_value_int32_array(nvpair_t *nvp, int32_t **val, uint_t *nelem) 18407c478bd9Sstevel@tonic-gate { 18417c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT32_ARRAY, nelem, val)); 18427c478bd9Sstevel@tonic-gate } 18437c478bd9Sstevel@tonic-gate 18447c478bd9Sstevel@tonic-gate int 18457c478bd9Sstevel@tonic-gate nvpair_value_uint32_array(nvpair_t *nvp, uint32_t **val, uint_t *nelem) 18467c478bd9Sstevel@tonic-gate { 18477c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT32_ARRAY, nelem, val)); 18487c478bd9Sstevel@tonic-gate } 18497c478bd9Sstevel@tonic-gate 18507c478bd9Sstevel@tonic-gate int 18517c478bd9Sstevel@tonic-gate nvpair_value_int64_array(nvpair_t *nvp, int64_t **val, uint_t *nelem) 18527c478bd9Sstevel@tonic-gate { 18537c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT64_ARRAY, nelem, val)); 18547c478bd9Sstevel@tonic-gate } 18557c478bd9Sstevel@tonic-gate 18567c478bd9Sstevel@tonic-gate int 18577c478bd9Sstevel@tonic-gate nvpair_value_uint64_array(nvpair_t *nvp, uint64_t **val, uint_t *nelem) 18587c478bd9Sstevel@tonic-gate { 18597c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT64_ARRAY, nelem, val)); 18607c478bd9Sstevel@tonic-gate } 18617c478bd9Sstevel@tonic-gate 18627c478bd9Sstevel@tonic-gate int 18637c478bd9Sstevel@tonic-gate nvpair_value_string_array(nvpair_t *nvp, char ***val, uint_t *nelem) 18647c478bd9Sstevel@tonic-gate { 18657c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_STRING_ARRAY, nelem, val)); 18667c478bd9Sstevel@tonic-gate } 18677c478bd9Sstevel@tonic-gate 18687c478bd9Sstevel@tonic-gate int 18697c478bd9Sstevel@tonic-gate nvpair_value_nvlist_array(nvpair_t *nvp, nvlist_t ***val, uint_t *nelem) 18707c478bd9Sstevel@tonic-gate { 18717c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_NVLIST_ARRAY, nelem, val)); 18727c478bd9Sstevel@tonic-gate } 18737c478bd9Sstevel@tonic-gate 18747c478bd9Sstevel@tonic-gate int 18757c478bd9Sstevel@tonic-gate nvpair_value_hrtime(nvpair_t *nvp, hrtime_t *val) 18767c478bd9Sstevel@tonic-gate { 18777c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_HRTIME, NULL, val)); 18787c478bd9Sstevel@tonic-gate } 18797c478bd9Sstevel@tonic-gate 18807c478bd9Sstevel@tonic-gate /* 18817c478bd9Sstevel@tonic-gate * Add specified pair to the list. 18827c478bd9Sstevel@tonic-gate */ 18837c478bd9Sstevel@tonic-gate int 18847c478bd9Sstevel@tonic-gate nvlist_add_nvpair(nvlist_t *nvl, nvpair_t *nvp) 18857c478bd9Sstevel@tonic-gate { 18867c478bd9Sstevel@tonic-gate if (nvl == NULL || nvp == NULL) 18877c478bd9Sstevel@tonic-gate return (EINVAL); 18887c478bd9Sstevel@tonic-gate 18897c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, NVP_NAME(nvp), NVP_TYPE(nvp), 18907c478bd9Sstevel@tonic-gate NVP_NELEM(nvp), NVP_VALUE(nvp))); 18917c478bd9Sstevel@tonic-gate } 18927c478bd9Sstevel@tonic-gate 18937c478bd9Sstevel@tonic-gate /* 18947c478bd9Sstevel@tonic-gate * Merge the supplied nvlists and put the result in dst. 18957c478bd9Sstevel@tonic-gate * The merged list will contain all names specified in both lists, 18967c478bd9Sstevel@tonic-gate * the values are taken from nvl in the case of duplicates. 18977c478bd9Sstevel@tonic-gate * Return 0 on success. 18987c478bd9Sstevel@tonic-gate */ 18997c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 19007c478bd9Sstevel@tonic-gate int 19017c478bd9Sstevel@tonic-gate nvlist_merge(nvlist_t *dst, nvlist_t *nvl, int flag) 19027c478bd9Sstevel@tonic-gate { 19037c478bd9Sstevel@tonic-gate if (nvl == NULL || dst == NULL) 19047c478bd9Sstevel@tonic-gate return (EINVAL); 19057c478bd9Sstevel@tonic-gate 19067c478bd9Sstevel@tonic-gate if (dst != nvl) 19077c478bd9Sstevel@tonic-gate return (nvlist_copy_pairs(nvl, dst)); 19087c478bd9Sstevel@tonic-gate 19097c478bd9Sstevel@tonic-gate return (0); 19107c478bd9Sstevel@tonic-gate } 19117c478bd9Sstevel@tonic-gate 19127c478bd9Sstevel@tonic-gate /* 19137c478bd9Sstevel@tonic-gate * Encoding related routines 19147c478bd9Sstevel@tonic-gate */ 19157c478bd9Sstevel@tonic-gate #define NVS_OP_ENCODE 0 19167c478bd9Sstevel@tonic-gate #define NVS_OP_DECODE 1 19177c478bd9Sstevel@tonic-gate #define NVS_OP_GETSIZE 2 19187c478bd9Sstevel@tonic-gate 19197c478bd9Sstevel@tonic-gate typedef struct nvs_ops nvs_ops_t; 19207c478bd9Sstevel@tonic-gate 19217c478bd9Sstevel@tonic-gate typedef struct { 19227c478bd9Sstevel@tonic-gate int nvs_op; 19237c478bd9Sstevel@tonic-gate const nvs_ops_t *nvs_ops; 19247c478bd9Sstevel@tonic-gate void *nvs_private; 19257c478bd9Sstevel@tonic-gate nvpriv_t *nvs_priv; 19267c478bd9Sstevel@tonic-gate } nvstream_t; 19277c478bd9Sstevel@tonic-gate 19287c478bd9Sstevel@tonic-gate /* 19297c478bd9Sstevel@tonic-gate * nvs operations are: 19307c478bd9Sstevel@tonic-gate * - nvs_nvlist 19317c478bd9Sstevel@tonic-gate * encoding / decoding of a nvlist header (nvlist_t) 19327c478bd9Sstevel@tonic-gate * calculates the size used for header and end detection 19337c478bd9Sstevel@tonic-gate * 19347c478bd9Sstevel@tonic-gate * - nvs_nvpair 19357c478bd9Sstevel@tonic-gate * responsible for the first part of encoding / decoding of an nvpair 19367c478bd9Sstevel@tonic-gate * calculates the decoded size of an nvpair 19377c478bd9Sstevel@tonic-gate * 19387c478bd9Sstevel@tonic-gate * - nvs_nvp_op 19397c478bd9Sstevel@tonic-gate * second part of encoding / decoding of an nvpair 19407c478bd9Sstevel@tonic-gate * 19417c478bd9Sstevel@tonic-gate * - nvs_nvp_size 19427c478bd9Sstevel@tonic-gate * calculates the encoding size of an nvpair 19437c478bd9Sstevel@tonic-gate * 19447c478bd9Sstevel@tonic-gate * - nvs_nvl_fini 19457c478bd9Sstevel@tonic-gate * encodes the end detection mark (zeros). 19467c478bd9Sstevel@tonic-gate */ 19477c478bd9Sstevel@tonic-gate struct nvs_ops { 19487c478bd9Sstevel@tonic-gate int (*nvs_nvlist)(nvstream_t *, nvlist_t *, size_t *); 19497c478bd9Sstevel@tonic-gate int (*nvs_nvpair)(nvstream_t *, nvpair_t *, size_t *); 19507c478bd9Sstevel@tonic-gate int (*nvs_nvp_op)(nvstream_t *, nvpair_t *); 19517c478bd9Sstevel@tonic-gate int (*nvs_nvp_size)(nvstream_t *, nvpair_t *, size_t *); 19527c478bd9Sstevel@tonic-gate int (*nvs_nvl_fini)(nvstream_t *); 19537c478bd9Sstevel@tonic-gate }; 19547c478bd9Sstevel@tonic-gate 19557c478bd9Sstevel@tonic-gate typedef struct { 19567c478bd9Sstevel@tonic-gate char nvh_encoding; /* nvs encoding method */ 19577c478bd9Sstevel@tonic-gate char nvh_endian; /* nvs endian */ 19587c478bd9Sstevel@tonic-gate char nvh_reserved1; /* reserved for future use */ 19597c478bd9Sstevel@tonic-gate char nvh_reserved2; /* reserved for future use */ 19607c478bd9Sstevel@tonic-gate } nvs_header_t; 19617c478bd9Sstevel@tonic-gate 19627c478bd9Sstevel@tonic-gate static int 19637c478bd9Sstevel@tonic-gate nvs_encode_pairs(nvstream_t *nvs, nvlist_t *nvl) 19647c478bd9Sstevel@tonic-gate { 19657c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 19667c478bd9Sstevel@tonic-gate i_nvp_t *curr; 19677c478bd9Sstevel@tonic-gate 19687c478bd9Sstevel@tonic-gate /* 19697c478bd9Sstevel@tonic-gate * Walk nvpair in list and encode each nvpair 19707c478bd9Sstevel@tonic-gate */ 19717c478bd9Sstevel@tonic-gate for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) 19727c478bd9Sstevel@tonic-gate if (nvs->nvs_ops->nvs_nvpair(nvs, &curr->nvi_nvp, NULL) != 0) 19737c478bd9Sstevel@tonic-gate return (EFAULT); 19747c478bd9Sstevel@tonic-gate 19757c478bd9Sstevel@tonic-gate return (nvs->nvs_ops->nvs_nvl_fini(nvs)); 19767c478bd9Sstevel@tonic-gate } 19777c478bd9Sstevel@tonic-gate 19787c478bd9Sstevel@tonic-gate static int 19797c478bd9Sstevel@tonic-gate nvs_decode_pairs(nvstream_t *nvs, nvlist_t *nvl) 19807c478bd9Sstevel@tonic-gate { 19817c478bd9Sstevel@tonic-gate nvpair_t *nvp; 19827c478bd9Sstevel@tonic-gate size_t nvsize; 19837c478bd9Sstevel@tonic-gate int err; 19847c478bd9Sstevel@tonic-gate 19857c478bd9Sstevel@tonic-gate /* 19867c478bd9Sstevel@tonic-gate * Get decoded size of next pair in stream, alloc 19877c478bd9Sstevel@tonic-gate * memory for nvpair_t, then decode the nvpair 19887c478bd9Sstevel@tonic-gate */ 19897c478bd9Sstevel@tonic-gate while ((err = nvs->nvs_ops->nvs_nvpair(nvs, NULL, &nvsize)) == 0) { 19907c478bd9Sstevel@tonic-gate if (nvsize == 0) /* end of list */ 19917c478bd9Sstevel@tonic-gate break; 19927c478bd9Sstevel@tonic-gate 19937c478bd9Sstevel@tonic-gate /* make sure len makes sense */ 19947c478bd9Sstevel@tonic-gate if (nvsize < NVP_SIZE_CALC(1, 0)) 19957c478bd9Sstevel@tonic-gate return (EFAULT); 19967c478bd9Sstevel@tonic-gate 19977c478bd9Sstevel@tonic-gate if ((nvp = nvp_buf_alloc(nvl, nvsize)) == NULL) 19987c478bd9Sstevel@tonic-gate return (ENOMEM); 19997c478bd9Sstevel@tonic-gate 20007c478bd9Sstevel@tonic-gate if ((err = nvs->nvs_ops->nvs_nvp_op(nvs, nvp)) != 0) { 20017c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 20027c478bd9Sstevel@tonic-gate return (err); 20037c478bd9Sstevel@tonic-gate } 20047c478bd9Sstevel@tonic-gate 20057c478bd9Sstevel@tonic-gate if (i_validate_nvpair(nvp) != 0) { 20067c478bd9Sstevel@tonic-gate nvpair_free(nvp); 20077c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 20087c478bd9Sstevel@tonic-gate return (EFAULT); 20097c478bd9Sstevel@tonic-gate } 20107c478bd9Sstevel@tonic-gate 20117c478bd9Sstevel@tonic-gate nvp_buf_link(nvl, nvp); 20127c478bd9Sstevel@tonic-gate } 20137c478bd9Sstevel@tonic-gate return (err); 20147c478bd9Sstevel@tonic-gate } 20157c478bd9Sstevel@tonic-gate 20167c478bd9Sstevel@tonic-gate static int 20177c478bd9Sstevel@tonic-gate nvs_getsize_pairs(nvstream_t *nvs, nvlist_t *nvl, size_t *buflen) 20187c478bd9Sstevel@tonic-gate { 20197c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 20207c478bd9Sstevel@tonic-gate i_nvp_t *curr; 20217c478bd9Sstevel@tonic-gate uint64_t nvsize = *buflen; 20227c478bd9Sstevel@tonic-gate size_t size; 20237c478bd9Sstevel@tonic-gate 20247c478bd9Sstevel@tonic-gate /* 20257c478bd9Sstevel@tonic-gate * Get encoded size of nvpairs in nvlist 20267c478bd9Sstevel@tonic-gate */ 20277c478bd9Sstevel@tonic-gate for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) { 20287c478bd9Sstevel@tonic-gate if (nvs->nvs_ops->nvs_nvp_size(nvs, &curr->nvi_nvp, &size) != 0) 20297c478bd9Sstevel@tonic-gate return (EINVAL); 20307c478bd9Sstevel@tonic-gate 20317c478bd9Sstevel@tonic-gate if ((nvsize += size) > INT32_MAX) 20327c478bd9Sstevel@tonic-gate return (EINVAL); 20337c478bd9Sstevel@tonic-gate } 20347c478bd9Sstevel@tonic-gate 20357c478bd9Sstevel@tonic-gate *buflen = nvsize; 20367c478bd9Sstevel@tonic-gate return (0); 20377c478bd9Sstevel@tonic-gate } 20387c478bd9Sstevel@tonic-gate 20397c478bd9Sstevel@tonic-gate static int 20407c478bd9Sstevel@tonic-gate nvs_operation(nvstream_t *nvs, nvlist_t *nvl, size_t *buflen) 20417c478bd9Sstevel@tonic-gate { 20427c478bd9Sstevel@tonic-gate int err; 20437c478bd9Sstevel@tonic-gate 20445ad82045Snd if (nvl->nvl_priv == 0) 20457c478bd9Sstevel@tonic-gate return (EFAULT); 20467c478bd9Sstevel@tonic-gate 20477c478bd9Sstevel@tonic-gate /* 20487c478bd9Sstevel@tonic-gate * Perform the operation, starting with header, then each nvpair 20497c478bd9Sstevel@tonic-gate */ 20507c478bd9Sstevel@tonic-gate if ((err = nvs->nvs_ops->nvs_nvlist(nvs, nvl, buflen)) != 0) 20517c478bd9Sstevel@tonic-gate return (err); 20527c478bd9Sstevel@tonic-gate 20537c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 20547c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 20557c478bd9Sstevel@tonic-gate err = nvs_encode_pairs(nvs, nvl); 20567c478bd9Sstevel@tonic-gate break; 20577c478bd9Sstevel@tonic-gate 20587c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 20597c478bd9Sstevel@tonic-gate err = nvs_decode_pairs(nvs, nvl); 20607c478bd9Sstevel@tonic-gate break; 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: 20637c478bd9Sstevel@tonic-gate err = nvs_getsize_pairs(nvs, nvl, buflen); 20647c478bd9Sstevel@tonic-gate break; 20657c478bd9Sstevel@tonic-gate 20667c478bd9Sstevel@tonic-gate default: 20677c478bd9Sstevel@tonic-gate err = EINVAL; 20687c478bd9Sstevel@tonic-gate } 20697c478bd9Sstevel@tonic-gate 20707c478bd9Sstevel@tonic-gate return (err); 20717c478bd9Sstevel@tonic-gate } 20727c478bd9Sstevel@tonic-gate 20737c478bd9Sstevel@tonic-gate static int 20747c478bd9Sstevel@tonic-gate nvs_embedded(nvstream_t *nvs, nvlist_t *embedded) 20757c478bd9Sstevel@tonic-gate { 20767c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 20777c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 20787c478bd9Sstevel@tonic-gate return (nvs_operation(nvs, embedded, NULL)); 20797c478bd9Sstevel@tonic-gate 20807c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: { 20817c478bd9Sstevel@tonic-gate nvpriv_t *priv; 20827c478bd9Sstevel@tonic-gate int err; 20837c478bd9Sstevel@tonic-gate 20847c478bd9Sstevel@tonic-gate if (embedded->nvl_version != NV_VERSION) 20857c478bd9Sstevel@tonic-gate return (ENOTSUP); 20867c478bd9Sstevel@tonic-gate 20877c478bd9Sstevel@tonic-gate if ((priv = nv_priv_alloc_embedded(nvs->nvs_priv)) == NULL) 20887c478bd9Sstevel@tonic-gate return (ENOMEM); 20897c478bd9Sstevel@tonic-gate 20907c478bd9Sstevel@tonic-gate nvlist_init(embedded, embedded->nvl_nvflag, priv); 20917c478bd9Sstevel@tonic-gate 20927c478bd9Sstevel@tonic-gate if ((err = nvs_operation(nvs, embedded, NULL)) != 0) 20937c478bd9Sstevel@tonic-gate nvlist_free(embedded); 20947c478bd9Sstevel@tonic-gate return (err); 20957c478bd9Sstevel@tonic-gate } 20967c478bd9Sstevel@tonic-gate default: 20977c478bd9Sstevel@tonic-gate break; 20987c478bd9Sstevel@tonic-gate } 20997c478bd9Sstevel@tonic-gate 21007c478bd9Sstevel@tonic-gate return (EINVAL); 21017c478bd9Sstevel@tonic-gate } 21027c478bd9Sstevel@tonic-gate 21037c478bd9Sstevel@tonic-gate static int 21047c478bd9Sstevel@tonic-gate nvs_embedded_nvl_array(nvstream_t *nvs, nvpair_t *nvp, size_t *size) 21057c478bd9Sstevel@tonic-gate { 21067c478bd9Sstevel@tonic-gate size_t nelem = NVP_NELEM(nvp); 21077c478bd9Sstevel@tonic-gate nvlist_t **nvlp = EMBEDDED_NVL_ARRAY(nvp); 21087c478bd9Sstevel@tonic-gate int i; 21097c478bd9Sstevel@tonic-gate 21107c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 21117c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 21127c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) 21137c478bd9Sstevel@tonic-gate if (nvs_embedded(nvs, nvlp[i]) != 0) 21147c478bd9Sstevel@tonic-gate return (EFAULT); 21157c478bd9Sstevel@tonic-gate break; 21167c478bd9Sstevel@tonic-gate 21177c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: { 21187c478bd9Sstevel@tonic-gate size_t len = nelem * sizeof (uint64_t); 21197c478bd9Sstevel@tonic-gate nvlist_t *embedded = (nvlist_t *)((uintptr_t)nvlp + len); 21207c478bd9Sstevel@tonic-gate 21217c478bd9Sstevel@tonic-gate bzero(nvlp, len); /* don't trust packed data */ 21227c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 21237c478bd9Sstevel@tonic-gate if (nvs_embedded(nvs, embedded) != 0) { 21247c478bd9Sstevel@tonic-gate nvpair_free(nvp); 21257c478bd9Sstevel@tonic-gate return (EFAULT); 21267c478bd9Sstevel@tonic-gate } 21277c478bd9Sstevel@tonic-gate 21287c478bd9Sstevel@tonic-gate nvlp[i] = embedded++; 21297c478bd9Sstevel@tonic-gate } 21307c478bd9Sstevel@tonic-gate break; 21317c478bd9Sstevel@tonic-gate } 21327c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: { 21337c478bd9Sstevel@tonic-gate uint64_t nvsize = 0; 21347c478bd9Sstevel@tonic-gate 21357c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 21367c478bd9Sstevel@tonic-gate size_t nvp_sz = 0; 21377c478bd9Sstevel@tonic-gate 21387c478bd9Sstevel@tonic-gate if (nvs_operation(nvs, nvlp[i], &nvp_sz) != 0) 21397c478bd9Sstevel@tonic-gate return (EINVAL); 21407c478bd9Sstevel@tonic-gate 21417c478bd9Sstevel@tonic-gate if ((nvsize += nvp_sz) > INT32_MAX) 21427c478bd9Sstevel@tonic-gate return (EINVAL); 21437c478bd9Sstevel@tonic-gate } 21447c478bd9Sstevel@tonic-gate 21457c478bd9Sstevel@tonic-gate *size = nvsize; 21467c478bd9Sstevel@tonic-gate break; 21477c478bd9Sstevel@tonic-gate } 21487c478bd9Sstevel@tonic-gate default: 21497c478bd9Sstevel@tonic-gate return (EINVAL); 21507c478bd9Sstevel@tonic-gate } 21517c478bd9Sstevel@tonic-gate 21527c478bd9Sstevel@tonic-gate return (0); 21537c478bd9Sstevel@tonic-gate } 21547c478bd9Sstevel@tonic-gate 21557c478bd9Sstevel@tonic-gate static int nvs_native(nvstream_t *, nvlist_t *, char *, size_t *); 21567c478bd9Sstevel@tonic-gate static int nvs_xdr(nvstream_t *, nvlist_t *, char *, size_t *); 21577c478bd9Sstevel@tonic-gate 21587c478bd9Sstevel@tonic-gate /* 21597c478bd9Sstevel@tonic-gate * Common routine for nvlist operations: 21607c478bd9Sstevel@tonic-gate * encode, decode, getsize (encoded size). 21617c478bd9Sstevel@tonic-gate */ 21627c478bd9Sstevel@tonic-gate static int 21637c478bd9Sstevel@tonic-gate nvlist_common(nvlist_t *nvl, char *buf, size_t *buflen, int encoding, 21647c478bd9Sstevel@tonic-gate int nvs_op) 21657c478bd9Sstevel@tonic-gate { 21667c478bd9Sstevel@tonic-gate int err = 0; 21677c478bd9Sstevel@tonic-gate nvstream_t nvs; 21687c478bd9Sstevel@tonic-gate int nvl_endian; 21697c478bd9Sstevel@tonic-gate #ifdef _LITTLE_ENDIAN 21707c478bd9Sstevel@tonic-gate int host_endian = 1; 21717c478bd9Sstevel@tonic-gate #else 21727c478bd9Sstevel@tonic-gate int host_endian = 0; 21737c478bd9Sstevel@tonic-gate #endif /* _LITTLE_ENDIAN */ 21747c478bd9Sstevel@tonic-gate nvs_header_t *nvh = (void *)buf; 21757c478bd9Sstevel@tonic-gate 21767c478bd9Sstevel@tonic-gate if (buflen == NULL || nvl == NULL || 21777c478bd9Sstevel@tonic-gate (nvs.nvs_priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 21787c478bd9Sstevel@tonic-gate return (EINVAL); 21797c478bd9Sstevel@tonic-gate 21807c478bd9Sstevel@tonic-gate nvs.nvs_op = nvs_op; 21817c478bd9Sstevel@tonic-gate 21827c478bd9Sstevel@tonic-gate /* 21837c478bd9Sstevel@tonic-gate * For NVS_OP_ENCODE and NVS_OP_DECODE make sure an nvlist and 21847c478bd9Sstevel@tonic-gate * a buffer is allocated. The first 4 bytes in the buffer are 21857c478bd9Sstevel@tonic-gate * used for encoding method and host endian. 21867c478bd9Sstevel@tonic-gate */ 21877c478bd9Sstevel@tonic-gate switch (nvs_op) { 21887c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 21897c478bd9Sstevel@tonic-gate if (buf == NULL || *buflen < sizeof (nvs_header_t)) 21907c478bd9Sstevel@tonic-gate return (EINVAL); 21917c478bd9Sstevel@tonic-gate 21927c478bd9Sstevel@tonic-gate nvh->nvh_encoding = encoding; 21937c478bd9Sstevel@tonic-gate nvh->nvh_endian = nvl_endian = host_endian; 21947c478bd9Sstevel@tonic-gate nvh->nvh_reserved1 = 0; 21957c478bd9Sstevel@tonic-gate nvh->nvh_reserved2 = 0; 21967c478bd9Sstevel@tonic-gate break; 21977c478bd9Sstevel@tonic-gate 21987c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 21997c478bd9Sstevel@tonic-gate if (buf == NULL || *buflen < sizeof (nvs_header_t)) 22007c478bd9Sstevel@tonic-gate return (EINVAL); 22017c478bd9Sstevel@tonic-gate 22027c478bd9Sstevel@tonic-gate /* get method of encoding from first byte */ 22037c478bd9Sstevel@tonic-gate encoding = nvh->nvh_encoding; 22047c478bd9Sstevel@tonic-gate nvl_endian = nvh->nvh_endian; 22057c478bd9Sstevel@tonic-gate break; 22067c478bd9Sstevel@tonic-gate 22077c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: 22087c478bd9Sstevel@tonic-gate nvl_endian = host_endian; 22097c478bd9Sstevel@tonic-gate 22107c478bd9Sstevel@tonic-gate /* 22117c478bd9Sstevel@tonic-gate * add the size for encoding 22127c478bd9Sstevel@tonic-gate */ 22137c478bd9Sstevel@tonic-gate *buflen = sizeof (nvs_header_t); 22147c478bd9Sstevel@tonic-gate break; 22157c478bd9Sstevel@tonic-gate 22167c478bd9Sstevel@tonic-gate default: 22177c478bd9Sstevel@tonic-gate return (ENOTSUP); 22187c478bd9Sstevel@tonic-gate } 22197c478bd9Sstevel@tonic-gate 22207c478bd9Sstevel@tonic-gate /* 22217c478bd9Sstevel@tonic-gate * Create an nvstream with proper encoding method 22227c478bd9Sstevel@tonic-gate */ 22237c478bd9Sstevel@tonic-gate switch (encoding) { 22247c478bd9Sstevel@tonic-gate case NV_ENCODE_NATIVE: 22257c478bd9Sstevel@tonic-gate /* 22267c478bd9Sstevel@tonic-gate * check endianness, in case we are unpacking 22277c478bd9Sstevel@tonic-gate * from a file 22287c478bd9Sstevel@tonic-gate */ 22297c478bd9Sstevel@tonic-gate if (nvl_endian != host_endian) 22307c478bd9Sstevel@tonic-gate return (ENOTSUP); 22317c478bd9Sstevel@tonic-gate err = nvs_native(&nvs, nvl, buf, buflen); 22327c478bd9Sstevel@tonic-gate break; 22337c478bd9Sstevel@tonic-gate case NV_ENCODE_XDR: 22347c478bd9Sstevel@tonic-gate err = nvs_xdr(&nvs, nvl, buf, buflen); 22357c478bd9Sstevel@tonic-gate break; 22367c478bd9Sstevel@tonic-gate default: 22377c478bd9Sstevel@tonic-gate err = ENOTSUP; 22387c478bd9Sstevel@tonic-gate break; 22397c478bd9Sstevel@tonic-gate } 22407c478bd9Sstevel@tonic-gate 22417c478bd9Sstevel@tonic-gate return (err); 22427c478bd9Sstevel@tonic-gate } 22437c478bd9Sstevel@tonic-gate 22447c478bd9Sstevel@tonic-gate int 22457c478bd9Sstevel@tonic-gate nvlist_size(nvlist_t *nvl, size_t *size, int encoding) 22467c478bd9Sstevel@tonic-gate { 22477c478bd9Sstevel@tonic-gate return (nvlist_common(nvl, NULL, size, encoding, NVS_OP_GETSIZE)); 22487c478bd9Sstevel@tonic-gate } 22497c478bd9Sstevel@tonic-gate 22507c478bd9Sstevel@tonic-gate /* 22517c478bd9Sstevel@tonic-gate * Pack nvlist into contiguous memory 22527c478bd9Sstevel@tonic-gate */ 22537c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 22547c478bd9Sstevel@tonic-gate int 22557c478bd9Sstevel@tonic-gate nvlist_pack(nvlist_t *nvl, char **bufp, size_t *buflen, int encoding, 22567c478bd9Sstevel@tonic-gate int kmflag) 22577c478bd9Sstevel@tonic-gate { 22587c478bd9Sstevel@tonic-gate #if defined(_KERNEL) && !defined(_BOOT) 22597c478bd9Sstevel@tonic-gate return (nvlist_xpack(nvl, bufp, buflen, encoding, 22607c478bd9Sstevel@tonic-gate (kmflag == KM_SLEEP ? nv_alloc_sleep : nv_alloc_nosleep))); 22617c478bd9Sstevel@tonic-gate #else 22627c478bd9Sstevel@tonic-gate return (nvlist_xpack(nvl, bufp, buflen, encoding, nv_alloc_nosleep)); 22637c478bd9Sstevel@tonic-gate #endif 22647c478bd9Sstevel@tonic-gate } 22657c478bd9Sstevel@tonic-gate 22667c478bd9Sstevel@tonic-gate int 22677c478bd9Sstevel@tonic-gate nvlist_xpack(nvlist_t *nvl, char **bufp, size_t *buflen, int encoding, 22687c478bd9Sstevel@tonic-gate nv_alloc_t *nva) 22697c478bd9Sstevel@tonic-gate { 22707c478bd9Sstevel@tonic-gate nvpriv_t nvpriv; 22717c478bd9Sstevel@tonic-gate size_t alloc_size; 22727c478bd9Sstevel@tonic-gate char *buf; 22737c478bd9Sstevel@tonic-gate int err; 22747c478bd9Sstevel@tonic-gate 22757c478bd9Sstevel@tonic-gate if (nva == NULL || nvl == NULL || bufp == NULL || buflen == NULL) 22767c478bd9Sstevel@tonic-gate return (EINVAL); 22777c478bd9Sstevel@tonic-gate 22787c478bd9Sstevel@tonic-gate if (*bufp != NULL) 22797c478bd9Sstevel@tonic-gate return (nvlist_common(nvl, *bufp, buflen, encoding, 22807c478bd9Sstevel@tonic-gate NVS_OP_ENCODE)); 22817c478bd9Sstevel@tonic-gate 22827c478bd9Sstevel@tonic-gate /* 22837c478bd9Sstevel@tonic-gate * Here is a difficult situation: 22847c478bd9Sstevel@tonic-gate * 1. The nvlist has fixed allocator properties. 22857c478bd9Sstevel@tonic-gate * All other nvlist routines (like nvlist_add_*, ...) use 22867c478bd9Sstevel@tonic-gate * these properties. 22877c478bd9Sstevel@tonic-gate * 2. When using nvlist_pack() the user can specify his own 22887c478bd9Sstevel@tonic-gate * allocator properties (e.g. by using KM_NOSLEEP). 22897c478bd9Sstevel@tonic-gate * 22907c478bd9Sstevel@tonic-gate * We use the user specified properties (2). A clearer solution 22917c478bd9Sstevel@tonic-gate * will be to remove the kmflag from nvlist_pack(), but we will 22927c478bd9Sstevel@tonic-gate * not change the interface. 22937c478bd9Sstevel@tonic-gate */ 22947c478bd9Sstevel@tonic-gate nv_priv_init(&nvpriv, nva, 0); 22957c478bd9Sstevel@tonic-gate 22967c478bd9Sstevel@tonic-gate if (err = nvlist_size(nvl, &alloc_size, encoding)) 22977c478bd9Sstevel@tonic-gate return (err); 22987c478bd9Sstevel@tonic-gate 22997c478bd9Sstevel@tonic-gate if ((buf = nv_mem_zalloc(&nvpriv, alloc_size)) == NULL) 23007c478bd9Sstevel@tonic-gate return (ENOMEM); 23017c478bd9Sstevel@tonic-gate 23027c478bd9Sstevel@tonic-gate if ((err = nvlist_common(nvl, buf, &alloc_size, encoding, 23037c478bd9Sstevel@tonic-gate NVS_OP_ENCODE)) != 0) { 23047c478bd9Sstevel@tonic-gate nv_mem_free(&nvpriv, buf, alloc_size); 23057c478bd9Sstevel@tonic-gate } else { 23067c478bd9Sstevel@tonic-gate *buflen = alloc_size; 23077c478bd9Sstevel@tonic-gate *bufp = buf; 23087c478bd9Sstevel@tonic-gate } 23097c478bd9Sstevel@tonic-gate 23107c478bd9Sstevel@tonic-gate return (err); 23117c478bd9Sstevel@tonic-gate } 23127c478bd9Sstevel@tonic-gate 23137c478bd9Sstevel@tonic-gate /* 23147c478bd9Sstevel@tonic-gate * Unpack buf into an nvlist_t 23157c478bd9Sstevel@tonic-gate */ 23167c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 23177c478bd9Sstevel@tonic-gate int 23187c478bd9Sstevel@tonic-gate nvlist_unpack(char *buf, size_t buflen, nvlist_t **nvlp, int kmflag) 23197c478bd9Sstevel@tonic-gate { 23207c478bd9Sstevel@tonic-gate #if defined(_KERNEL) && !defined(_BOOT) 23217c478bd9Sstevel@tonic-gate return (nvlist_xunpack(buf, buflen, nvlp, 23227c478bd9Sstevel@tonic-gate (kmflag == KM_SLEEP ? nv_alloc_sleep : nv_alloc_nosleep))); 23237c478bd9Sstevel@tonic-gate #else 23247c478bd9Sstevel@tonic-gate return (nvlist_xunpack(buf, buflen, nvlp, nv_alloc_nosleep)); 23257c478bd9Sstevel@tonic-gate #endif 23267c478bd9Sstevel@tonic-gate } 23277c478bd9Sstevel@tonic-gate 23287c478bd9Sstevel@tonic-gate int 23297c478bd9Sstevel@tonic-gate nvlist_xunpack(char *buf, size_t buflen, nvlist_t **nvlp, nv_alloc_t *nva) 23307c478bd9Sstevel@tonic-gate { 23317c478bd9Sstevel@tonic-gate nvlist_t *nvl; 23327c478bd9Sstevel@tonic-gate int err; 23337c478bd9Sstevel@tonic-gate 23347c478bd9Sstevel@tonic-gate if (nvlp == NULL) 23357c478bd9Sstevel@tonic-gate return (EINVAL); 23367c478bd9Sstevel@tonic-gate 23377c478bd9Sstevel@tonic-gate if ((err = nvlist_xalloc(&nvl, 0, nva)) != 0) 23387c478bd9Sstevel@tonic-gate return (err); 23397c478bd9Sstevel@tonic-gate 23407c478bd9Sstevel@tonic-gate if ((err = nvlist_common(nvl, buf, &buflen, 0, NVS_OP_DECODE)) != 0) 23417c478bd9Sstevel@tonic-gate nvlist_free(nvl); 23427c478bd9Sstevel@tonic-gate else 23437c478bd9Sstevel@tonic-gate *nvlp = nvl; 23447c478bd9Sstevel@tonic-gate 23457c478bd9Sstevel@tonic-gate return (err); 23467c478bd9Sstevel@tonic-gate } 23477c478bd9Sstevel@tonic-gate 23487c478bd9Sstevel@tonic-gate /* 23497c478bd9Sstevel@tonic-gate * Native encoding functions 23507c478bd9Sstevel@tonic-gate */ 23517c478bd9Sstevel@tonic-gate typedef struct { 23527c478bd9Sstevel@tonic-gate /* 23537c478bd9Sstevel@tonic-gate * This structure is used when decoding a packed nvpair in 23547c478bd9Sstevel@tonic-gate * the native format. n_base points to a buffer containing the 23557c478bd9Sstevel@tonic-gate * packed nvpair. n_end is a pointer to the end of the buffer. 23567c478bd9Sstevel@tonic-gate * (n_end actually points to the first byte past the end of the 23577c478bd9Sstevel@tonic-gate * buffer.) n_curr is a pointer that lies between n_base and n_end. 23587c478bd9Sstevel@tonic-gate * It points to the current data that we are decoding. 23597c478bd9Sstevel@tonic-gate * The amount of data left in the buffer is equal to n_end - n_curr. 23607c478bd9Sstevel@tonic-gate * n_flag is used to recognize a packed embedded list. 23617c478bd9Sstevel@tonic-gate */ 23627c478bd9Sstevel@tonic-gate caddr_t n_base; 23637c478bd9Sstevel@tonic-gate caddr_t n_end; 23647c478bd9Sstevel@tonic-gate caddr_t n_curr; 23657c478bd9Sstevel@tonic-gate uint_t n_flag; 23667c478bd9Sstevel@tonic-gate } nvs_native_t; 23677c478bd9Sstevel@tonic-gate 23687c478bd9Sstevel@tonic-gate static int 23697c478bd9Sstevel@tonic-gate nvs_native_create(nvstream_t *nvs, nvs_native_t *native, char *buf, 23707c478bd9Sstevel@tonic-gate size_t buflen) 23717c478bd9Sstevel@tonic-gate { 23727c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 23737c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 23747c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 23757c478bd9Sstevel@tonic-gate nvs->nvs_private = native; 23767c478bd9Sstevel@tonic-gate native->n_curr = native->n_base = buf; 23777c478bd9Sstevel@tonic-gate native->n_end = buf + buflen; 23787c478bd9Sstevel@tonic-gate native->n_flag = 0; 23797c478bd9Sstevel@tonic-gate return (0); 23807c478bd9Sstevel@tonic-gate 23817c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: 23827c478bd9Sstevel@tonic-gate nvs->nvs_private = native; 23837c478bd9Sstevel@tonic-gate native->n_curr = native->n_base = native->n_end = NULL; 23847c478bd9Sstevel@tonic-gate native->n_flag = 0; 23857c478bd9Sstevel@tonic-gate return (0); 23867c478bd9Sstevel@tonic-gate default: 23877c478bd9Sstevel@tonic-gate return (EINVAL); 23887c478bd9Sstevel@tonic-gate } 23897c478bd9Sstevel@tonic-gate } 23907c478bd9Sstevel@tonic-gate 23917c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 23927c478bd9Sstevel@tonic-gate static void 23937c478bd9Sstevel@tonic-gate nvs_native_destroy(nvstream_t *nvs) 23947c478bd9Sstevel@tonic-gate { 23957c478bd9Sstevel@tonic-gate } 23967c478bd9Sstevel@tonic-gate 23977c478bd9Sstevel@tonic-gate static int 23987c478bd9Sstevel@tonic-gate native_cp(nvstream_t *nvs, void *buf, size_t size) 23997c478bd9Sstevel@tonic-gate { 24007c478bd9Sstevel@tonic-gate nvs_native_t *native = (nvs_native_t *)nvs->nvs_private; 24017c478bd9Sstevel@tonic-gate 24027c478bd9Sstevel@tonic-gate if (native->n_curr + size > native->n_end) 24037c478bd9Sstevel@tonic-gate return (EFAULT); 24047c478bd9Sstevel@tonic-gate 24057c478bd9Sstevel@tonic-gate /* 24067c478bd9Sstevel@tonic-gate * The bcopy() below eliminates alignment requirement 24077c478bd9Sstevel@tonic-gate * on the buffer (stream) and is preferred over direct access. 24087c478bd9Sstevel@tonic-gate */ 24097c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 24107c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 24117c478bd9Sstevel@tonic-gate bcopy(buf, native->n_curr, size); 24127c478bd9Sstevel@tonic-gate break; 24137c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 24147c478bd9Sstevel@tonic-gate bcopy(native->n_curr, buf, size); 24157c478bd9Sstevel@tonic-gate break; 24167c478bd9Sstevel@tonic-gate default: 24177c478bd9Sstevel@tonic-gate return (EINVAL); 24187c478bd9Sstevel@tonic-gate } 24197c478bd9Sstevel@tonic-gate 24207c478bd9Sstevel@tonic-gate native->n_curr += size; 24217c478bd9Sstevel@tonic-gate return (0); 24227c478bd9Sstevel@tonic-gate } 24237c478bd9Sstevel@tonic-gate 24247c478bd9Sstevel@tonic-gate /* 24257c478bd9Sstevel@tonic-gate * operate on nvlist_t header 24267c478bd9Sstevel@tonic-gate */ 24277c478bd9Sstevel@tonic-gate static int 24287c478bd9Sstevel@tonic-gate nvs_native_nvlist(nvstream_t *nvs, nvlist_t *nvl, size_t *size) 24297c478bd9Sstevel@tonic-gate { 24307c478bd9Sstevel@tonic-gate nvs_native_t *native = nvs->nvs_private; 24317c478bd9Sstevel@tonic-gate 24327c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 24337c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 24347c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 24357c478bd9Sstevel@tonic-gate if (native->n_flag) 24367c478bd9Sstevel@tonic-gate return (0); /* packed embedded list */ 24377c478bd9Sstevel@tonic-gate 24387c478bd9Sstevel@tonic-gate native->n_flag = 1; 24397c478bd9Sstevel@tonic-gate 24407c478bd9Sstevel@tonic-gate /* copy version and nvflag of the nvlist_t */ 24417c478bd9Sstevel@tonic-gate if (native_cp(nvs, &nvl->nvl_version, sizeof (int32_t)) != 0 || 24427c478bd9Sstevel@tonic-gate native_cp(nvs, &nvl->nvl_nvflag, sizeof (int32_t)) != 0) 24437c478bd9Sstevel@tonic-gate return (EFAULT); 24447c478bd9Sstevel@tonic-gate 24457c478bd9Sstevel@tonic-gate return (0); 24467c478bd9Sstevel@tonic-gate 24477c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: 24487c478bd9Sstevel@tonic-gate /* 24497c478bd9Sstevel@tonic-gate * if calculate for packed embedded list 24507c478bd9Sstevel@tonic-gate * 4 for end of the embedded list 24517c478bd9Sstevel@tonic-gate * else 24527c478bd9Sstevel@tonic-gate * 2 * sizeof (int32_t) for nvl_version and nvl_nvflag 24537c478bd9Sstevel@tonic-gate * and 4 for end of the entire list 24547c478bd9Sstevel@tonic-gate */ 24557c478bd9Sstevel@tonic-gate if (native->n_flag) { 24567c478bd9Sstevel@tonic-gate *size += 4; 24577c478bd9Sstevel@tonic-gate } else { 24587c478bd9Sstevel@tonic-gate native->n_flag = 1; 24597c478bd9Sstevel@tonic-gate *size += 2 * sizeof (int32_t) + 4; 24607c478bd9Sstevel@tonic-gate } 24617c478bd9Sstevel@tonic-gate 24627c478bd9Sstevel@tonic-gate return (0); 24637c478bd9Sstevel@tonic-gate 24647c478bd9Sstevel@tonic-gate default: 24657c478bd9Sstevel@tonic-gate return (EINVAL); 24667c478bd9Sstevel@tonic-gate } 24677c478bd9Sstevel@tonic-gate } 24687c478bd9Sstevel@tonic-gate 24697c478bd9Sstevel@tonic-gate static int 24707c478bd9Sstevel@tonic-gate nvs_native_nvl_fini(nvstream_t *nvs) 24717c478bd9Sstevel@tonic-gate { 24727c478bd9Sstevel@tonic-gate if (nvs->nvs_op == NVS_OP_ENCODE) { 24737c478bd9Sstevel@tonic-gate nvs_native_t *native = (nvs_native_t *)nvs->nvs_private; 24747c478bd9Sstevel@tonic-gate /* 24757c478bd9Sstevel@tonic-gate * Add 4 zero bytes at end of nvlist. They are used 24767c478bd9Sstevel@tonic-gate * for end detection by the decode routine. 24777c478bd9Sstevel@tonic-gate */ 24787c478bd9Sstevel@tonic-gate if (native->n_curr + sizeof (int) > native->n_end) 24797c478bd9Sstevel@tonic-gate return (EFAULT); 24807c478bd9Sstevel@tonic-gate 24817c478bd9Sstevel@tonic-gate bzero(native->n_curr, sizeof (int)); 24827c478bd9Sstevel@tonic-gate native->n_curr += sizeof (int); 24837c478bd9Sstevel@tonic-gate } 24847c478bd9Sstevel@tonic-gate 24857c478bd9Sstevel@tonic-gate return (0); 24867c478bd9Sstevel@tonic-gate } 24877c478bd9Sstevel@tonic-gate 24887c478bd9Sstevel@tonic-gate static int 24897c478bd9Sstevel@tonic-gate nvpair_native_embedded(nvstream_t *nvs, nvpair_t *nvp) 24907c478bd9Sstevel@tonic-gate { 24917c478bd9Sstevel@tonic-gate if (nvs->nvs_op == NVS_OP_ENCODE) { 24927c478bd9Sstevel@tonic-gate nvs_native_t *native = (nvs_native_t *)nvs->nvs_private; 24937c478bd9Sstevel@tonic-gate nvlist_t *packed = (void *) 24947c478bd9Sstevel@tonic-gate (native->n_curr - nvp->nvp_size + NVP_VALOFF(nvp)); 24957c478bd9Sstevel@tonic-gate /* 24967c478bd9Sstevel@tonic-gate * Null out the pointer that is meaningless in the packed 24977c478bd9Sstevel@tonic-gate * structure. The address may not be aligned, so we have 24987c478bd9Sstevel@tonic-gate * to use bzero. 24997c478bd9Sstevel@tonic-gate */ 25007c478bd9Sstevel@tonic-gate bzero(&packed->nvl_priv, sizeof (packed->nvl_priv)); 25017c478bd9Sstevel@tonic-gate } 25027c478bd9Sstevel@tonic-gate 25037c478bd9Sstevel@tonic-gate return (nvs_embedded(nvs, EMBEDDED_NVL(nvp))); 25047c478bd9Sstevel@tonic-gate } 25057c478bd9Sstevel@tonic-gate 25067c478bd9Sstevel@tonic-gate static int 25077c478bd9Sstevel@tonic-gate nvpair_native_embedded_array(nvstream_t *nvs, nvpair_t *nvp) 25087c478bd9Sstevel@tonic-gate { 25097c478bd9Sstevel@tonic-gate if (nvs->nvs_op == NVS_OP_ENCODE) { 25107c478bd9Sstevel@tonic-gate nvs_native_t *native = (nvs_native_t *)nvs->nvs_private; 25117c478bd9Sstevel@tonic-gate char *value = native->n_curr - nvp->nvp_size + NVP_VALOFF(nvp); 25127c478bd9Sstevel@tonic-gate size_t len = NVP_NELEM(nvp) * sizeof (uint64_t); 25137c478bd9Sstevel@tonic-gate nvlist_t *packed = (nvlist_t *)((uintptr_t)value + len); 25147c478bd9Sstevel@tonic-gate int i; 25157c478bd9Sstevel@tonic-gate /* 25167c478bd9Sstevel@tonic-gate * Null out pointers that are meaningless in the packed 25177c478bd9Sstevel@tonic-gate * structure. The addresses may not be aligned, so we have 25187c478bd9Sstevel@tonic-gate * to use bzero. 25197c478bd9Sstevel@tonic-gate */ 25207c478bd9Sstevel@tonic-gate bzero(value, len); 25217c478bd9Sstevel@tonic-gate 25227c478bd9Sstevel@tonic-gate for (i = 0; i < NVP_NELEM(nvp); i++, packed++) 25237c478bd9Sstevel@tonic-gate /* 25247c478bd9Sstevel@tonic-gate * Null out the pointer that is meaningless in the 25257c478bd9Sstevel@tonic-gate * packed structure. The address may not be aligned, 25267c478bd9Sstevel@tonic-gate * so we have to use bzero. 25277c478bd9Sstevel@tonic-gate */ 25287c478bd9Sstevel@tonic-gate bzero(&packed->nvl_priv, sizeof (packed->nvl_priv)); 25297c478bd9Sstevel@tonic-gate } 25307c478bd9Sstevel@tonic-gate 25317c478bd9Sstevel@tonic-gate return (nvs_embedded_nvl_array(nvs, nvp, NULL)); 25327c478bd9Sstevel@tonic-gate } 25337c478bd9Sstevel@tonic-gate 25347c478bd9Sstevel@tonic-gate static void 25357c478bd9Sstevel@tonic-gate nvpair_native_string_array(nvstream_t *nvs, nvpair_t *nvp) 25367c478bd9Sstevel@tonic-gate { 25377c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 25387c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: { 25397c478bd9Sstevel@tonic-gate nvs_native_t *native = (nvs_native_t *)nvs->nvs_private; 25407c478bd9Sstevel@tonic-gate uint64_t *strp = (void *) 25417c478bd9Sstevel@tonic-gate (native->n_curr - nvp->nvp_size + NVP_VALOFF(nvp)); 25427c478bd9Sstevel@tonic-gate /* 25437c478bd9Sstevel@tonic-gate * Null out pointers that are meaningless in the packed 25447c478bd9Sstevel@tonic-gate * structure. The addresses may not be aligned, so we have 25457c478bd9Sstevel@tonic-gate * to use bzero. 25467c478bd9Sstevel@tonic-gate */ 25477c478bd9Sstevel@tonic-gate bzero(strp, NVP_NELEM(nvp) * sizeof (uint64_t)); 25487c478bd9Sstevel@tonic-gate break; 25497c478bd9Sstevel@tonic-gate } 25507c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: { 25517c478bd9Sstevel@tonic-gate char **strp = (void *)NVP_VALUE(nvp); 25527c478bd9Sstevel@tonic-gate char *buf = ((char *)strp + NVP_NELEM(nvp) * sizeof (uint64_t)); 25537c478bd9Sstevel@tonic-gate int i; 25547c478bd9Sstevel@tonic-gate 25557c478bd9Sstevel@tonic-gate for (i = 0; i < NVP_NELEM(nvp); i++) { 25567c478bd9Sstevel@tonic-gate strp[i] = buf; 25577c478bd9Sstevel@tonic-gate buf += strlen(buf) + 1; 25587c478bd9Sstevel@tonic-gate } 25597c478bd9Sstevel@tonic-gate break; 25607c478bd9Sstevel@tonic-gate } 25617c478bd9Sstevel@tonic-gate } 25627c478bd9Sstevel@tonic-gate } 25637c478bd9Sstevel@tonic-gate 25647c478bd9Sstevel@tonic-gate static int 25657c478bd9Sstevel@tonic-gate nvs_native_nvp_op(nvstream_t *nvs, nvpair_t *nvp) 25667c478bd9Sstevel@tonic-gate { 25677c478bd9Sstevel@tonic-gate data_type_t type; 25687c478bd9Sstevel@tonic-gate int value_sz; 25697c478bd9Sstevel@tonic-gate int ret = 0; 25707c478bd9Sstevel@tonic-gate 25717c478bd9Sstevel@tonic-gate /* 25727c478bd9Sstevel@tonic-gate * We do the initial bcopy of the data before we look at 25737c478bd9Sstevel@tonic-gate * the nvpair type, because when we're decoding, we won't 25747c478bd9Sstevel@tonic-gate * have the correct values for the pair until we do the bcopy. 25757c478bd9Sstevel@tonic-gate */ 25767c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 25777c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 25787c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 25797c478bd9Sstevel@tonic-gate if (native_cp(nvs, nvp, nvp->nvp_size) != 0) 25807c478bd9Sstevel@tonic-gate return (EFAULT); 25817c478bd9Sstevel@tonic-gate break; 25827c478bd9Sstevel@tonic-gate default: 25837c478bd9Sstevel@tonic-gate return (EINVAL); 25847c478bd9Sstevel@tonic-gate } 25857c478bd9Sstevel@tonic-gate 25867c478bd9Sstevel@tonic-gate /* verify nvp_name_sz, check the name string length */ 25877c478bd9Sstevel@tonic-gate if (i_validate_nvpair_name(nvp) != 0) 25887c478bd9Sstevel@tonic-gate return (EFAULT); 25897c478bd9Sstevel@tonic-gate 25907c478bd9Sstevel@tonic-gate type = NVP_TYPE(nvp); 25917c478bd9Sstevel@tonic-gate 25927c478bd9Sstevel@tonic-gate /* 25937c478bd9Sstevel@tonic-gate * Verify type and nelem and get the value size. 25947c478bd9Sstevel@tonic-gate * In case of data types DATA_TYPE_STRING and DATA_TYPE_STRING_ARRAY 25957c478bd9Sstevel@tonic-gate * is the size of the string(s) excluded. 25967c478bd9Sstevel@tonic-gate */ 25977c478bd9Sstevel@tonic-gate if ((value_sz = i_get_value_size(type, NULL, NVP_NELEM(nvp))) < 0) 25987c478bd9Sstevel@tonic-gate return (EFAULT); 25997c478bd9Sstevel@tonic-gate 26007c478bd9Sstevel@tonic-gate if (NVP_SIZE_CALC(nvp->nvp_name_sz, value_sz) > nvp->nvp_size) 26017c478bd9Sstevel@tonic-gate return (EFAULT); 26027c478bd9Sstevel@tonic-gate 26037c478bd9Sstevel@tonic-gate switch (type) { 26047c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 26057c478bd9Sstevel@tonic-gate ret = nvpair_native_embedded(nvs, nvp); 26067c478bd9Sstevel@tonic-gate break; 26077c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: 26087c478bd9Sstevel@tonic-gate ret = nvpair_native_embedded_array(nvs, nvp); 26097c478bd9Sstevel@tonic-gate break; 26107c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: 26117c478bd9Sstevel@tonic-gate nvpair_native_string_array(nvs, nvp); 26127c478bd9Sstevel@tonic-gate break; 26137c478bd9Sstevel@tonic-gate default: 26147c478bd9Sstevel@tonic-gate break; 26157c478bd9Sstevel@tonic-gate } 26167c478bd9Sstevel@tonic-gate 26177c478bd9Sstevel@tonic-gate return (ret); 26187c478bd9Sstevel@tonic-gate } 26197c478bd9Sstevel@tonic-gate 26207c478bd9Sstevel@tonic-gate static int 26217c478bd9Sstevel@tonic-gate nvs_native_nvp_size(nvstream_t *nvs, nvpair_t *nvp, size_t *size) 26227c478bd9Sstevel@tonic-gate { 26237c478bd9Sstevel@tonic-gate uint64_t nvp_sz = nvp->nvp_size; 26247c478bd9Sstevel@tonic-gate 26257c478bd9Sstevel@tonic-gate switch (NVP_TYPE(nvp)) { 26267c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: { 26277c478bd9Sstevel@tonic-gate size_t nvsize = 0; 26287c478bd9Sstevel@tonic-gate 26297c478bd9Sstevel@tonic-gate if (nvs_operation(nvs, EMBEDDED_NVL(nvp), &nvsize) != 0) 26307c478bd9Sstevel@tonic-gate return (EINVAL); 26317c478bd9Sstevel@tonic-gate 26327c478bd9Sstevel@tonic-gate nvp_sz += nvsize; 26337c478bd9Sstevel@tonic-gate break; 26347c478bd9Sstevel@tonic-gate } 26357c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: { 26367c478bd9Sstevel@tonic-gate size_t nvsize; 26377c478bd9Sstevel@tonic-gate 26387c478bd9Sstevel@tonic-gate if (nvs_embedded_nvl_array(nvs, nvp, &nvsize) != 0) 26397c478bd9Sstevel@tonic-gate return (EINVAL); 26407c478bd9Sstevel@tonic-gate 26417c478bd9Sstevel@tonic-gate nvp_sz += nvsize; 26427c478bd9Sstevel@tonic-gate break; 26437c478bd9Sstevel@tonic-gate } 26447c478bd9Sstevel@tonic-gate default: 26457c478bd9Sstevel@tonic-gate break; 26467c478bd9Sstevel@tonic-gate } 26477c478bd9Sstevel@tonic-gate 26487c478bd9Sstevel@tonic-gate if (nvp_sz > INT32_MAX) 26497c478bd9Sstevel@tonic-gate return (EINVAL); 26507c478bd9Sstevel@tonic-gate 26517c478bd9Sstevel@tonic-gate *size = nvp_sz; 26527c478bd9Sstevel@tonic-gate 26537c478bd9Sstevel@tonic-gate return (0); 26547c478bd9Sstevel@tonic-gate } 26557c478bd9Sstevel@tonic-gate 26567c478bd9Sstevel@tonic-gate static int 26577c478bd9Sstevel@tonic-gate nvs_native_nvpair(nvstream_t *nvs, nvpair_t *nvp, size_t *size) 26587c478bd9Sstevel@tonic-gate { 26597c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 26607c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 26617c478bd9Sstevel@tonic-gate return (nvs_native_nvp_op(nvs, nvp)); 26627c478bd9Sstevel@tonic-gate 26637c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: { 26647c478bd9Sstevel@tonic-gate nvs_native_t *native = (nvs_native_t *)nvs->nvs_private; 26657c478bd9Sstevel@tonic-gate int32_t decode_len; 26667c478bd9Sstevel@tonic-gate 26677c478bd9Sstevel@tonic-gate /* try to read the size value from the stream */ 26687c478bd9Sstevel@tonic-gate if (native->n_curr + sizeof (int32_t) > native->n_end) 26697c478bd9Sstevel@tonic-gate return (EFAULT); 26707c478bd9Sstevel@tonic-gate bcopy(native->n_curr, &decode_len, sizeof (int32_t)); 26717c478bd9Sstevel@tonic-gate 26727c478bd9Sstevel@tonic-gate /* sanity check the size value */ 26737c478bd9Sstevel@tonic-gate if (decode_len < 0 || 26747c478bd9Sstevel@tonic-gate decode_len > native->n_end - native->n_curr) 26757c478bd9Sstevel@tonic-gate return (EFAULT); 26767c478bd9Sstevel@tonic-gate 26777c478bd9Sstevel@tonic-gate *size = decode_len; 26787c478bd9Sstevel@tonic-gate 26797c478bd9Sstevel@tonic-gate /* 26807c478bd9Sstevel@tonic-gate * If at the end of the stream then move the cursor 26817c478bd9Sstevel@tonic-gate * forward, otherwise nvpair_native_op() will read 26827c478bd9Sstevel@tonic-gate * the entire nvpair at the same cursor position. 26837c478bd9Sstevel@tonic-gate */ 26847c478bd9Sstevel@tonic-gate if (*size == 0) 26857c478bd9Sstevel@tonic-gate native->n_curr += sizeof (int32_t); 26867c478bd9Sstevel@tonic-gate break; 26877c478bd9Sstevel@tonic-gate } 26887c478bd9Sstevel@tonic-gate 26897c478bd9Sstevel@tonic-gate default: 26907c478bd9Sstevel@tonic-gate return (EINVAL); 26917c478bd9Sstevel@tonic-gate } 26927c478bd9Sstevel@tonic-gate 26937c478bd9Sstevel@tonic-gate return (0); 26947c478bd9Sstevel@tonic-gate } 26957c478bd9Sstevel@tonic-gate 26967c478bd9Sstevel@tonic-gate static const nvs_ops_t nvs_native_ops = { 26977c478bd9Sstevel@tonic-gate nvs_native_nvlist, 26987c478bd9Sstevel@tonic-gate nvs_native_nvpair, 26997c478bd9Sstevel@tonic-gate nvs_native_nvp_op, 27007c478bd9Sstevel@tonic-gate nvs_native_nvp_size, 27017c478bd9Sstevel@tonic-gate nvs_native_nvl_fini 27027c478bd9Sstevel@tonic-gate }; 27037c478bd9Sstevel@tonic-gate 27047c478bd9Sstevel@tonic-gate static int 27057c478bd9Sstevel@tonic-gate nvs_native(nvstream_t *nvs, nvlist_t *nvl, char *buf, size_t *buflen) 27067c478bd9Sstevel@tonic-gate { 27077c478bd9Sstevel@tonic-gate nvs_native_t native; 27087c478bd9Sstevel@tonic-gate int err; 27097c478bd9Sstevel@tonic-gate 27107c478bd9Sstevel@tonic-gate nvs->nvs_ops = &nvs_native_ops; 27117c478bd9Sstevel@tonic-gate 27127c478bd9Sstevel@tonic-gate if ((err = nvs_native_create(nvs, &native, buf + sizeof (nvs_header_t), 27137c478bd9Sstevel@tonic-gate *buflen - sizeof (nvs_header_t))) != 0) 27147c478bd9Sstevel@tonic-gate return (err); 27157c478bd9Sstevel@tonic-gate 27167c478bd9Sstevel@tonic-gate err = nvs_operation(nvs, nvl, buflen); 27177c478bd9Sstevel@tonic-gate 27187c478bd9Sstevel@tonic-gate nvs_native_destroy(nvs); 27197c478bd9Sstevel@tonic-gate 27207c478bd9Sstevel@tonic-gate return (err); 27217c478bd9Sstevel@tonic-gate } 27227c478bd9Sstevel@tonic-gate 27237c478bd9Sstevel@tonic-gate /* 27247c478bd9Sstevel@tonic-gate * XDR encoding functions 27257c478bd9Sstevel@tonic-gate * 27267c478bd9Sstevel@tonic-gate * An xdr packed nvlist is encoded as: 27277c478bd9Sstevel@tonic-gate * 27287c478bd9Sstevel@tonic-gate * - encoding methode and host endian (4 bytes) 27297c478bd9Sstevel@tonic-gate * - nvl_version (4 bytes) 27307c478bd9Sstevel@tonic-gate * - nvl_nvflag (4 bytes) 27317c478bd9Sstevel@tonic-gate * 27327c478bd9Sstevel@tonic-gate * - encoded nvpairs, the format of one xdr encoded nvpair is: 27337c478bd9Sstevel@tonic-gate * - encoded size of the nvpair (4 bytes) 27347c478bd9Sstevel@tonic-gate * - decoded size of the nvpair (4 bytes) 27357c478bd9Sstevel@tonic-gate * - name string, (4 + sizeof(NV_ALIGN4(string)) 27367c478bd9Sstevel@tonic-gate * a string is coded as size (4 bytes) and data 27377c478bd9Sstevel@tonic-gate * - data type (4 bytes) 27387c478bd9Sstevel@tonic-gate * - number of elements in the nvpair (4 bytes) 27397c478bd9Sstevel@tonic-gate * - data 27407c478bd9Sstevel@tonic-gate * 27417c478bd9Sstevel@tonic-gate * - 2 zero's for end of the entire list (8 bytes) 27427c478bd9Sstevel@tonic-gate */ 27437c478bd9Sstevel@tonic-gate static int 27447c478bd9Sstevel@tonic-gate nvs_xdr_create(nvstream_t *nvs, XDR *xdr, char *buf, size_t buflen) 27457c478bd9Sstevel@tonic-gate { 27467c478bd9Sstevel@tonic-gate /* xdr data must be 4 byte aligned */ 27477c478bd9Sstevel@tonic-gate if ((ulong_t)buf % 4 != 0) 27487c478bd9Sstevel@tonic-gate return (EFAULT); 27497c478bd9Sstevel@tonic-gate 27507c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 27517c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 27527c478bd9Sstevel@tonic-gate xdrmem_create(xdr, buf, (uint_t)buflen, XDR_ENCODE); 27537c478bd9Sstevel@tonic-gate nvs->nvs_private = xdr; 27547c478bd9Sstevel@tonic-gate return (0); 27557c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 27567c478bd9Sstevel@tonic-gate xdrmem_create(xdr, buf, (uint_t)buflen, XDR_DECODE); 27577c478bd9Sstevel@tonic-gate nvs->nvs_private = xdr; 27587c478bd9Sstevel@tonic-gate return (0); 27597c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: 27607c478bd9Sstevel@tonic-gate nvs->nvs_private = NULL; 27617c478bd9Sstevel@tonic-gate return (0); 27627c478bd9Sstevel@tonic-gate default: 27637c478bd9Sstevel@tonic-gate return (EINVAL); 27647c478bd9Sstevel@tonic-gate } 27657c478bd9Sstevel@tonic-gate } 27667c478bd9Sstevel@tonic-gate 27677c478bd9Sstevel@tonic-gate static void 27687c478bd9Sstevel@tonic-gate nvs_xdr_destroy(nvstream_t *nvs) 27697c478bd9Sstevel@tonic-gate { 27707c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 27717c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 27727c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 27737c478bd9Sstevel@tonic-gate xdr_destroy((XDR *)nvs->nvs_private); 27747c478bd9Sstevel@tonic-gate break; 27757c478bd9Sstevel@tonic-gate default: 27767c478bd9Sstevel@tonic-gate break; 27777c478bd9Sstevel@tonic-gate } 27787c478bd9Sstevel@tonic-gate } 27797c478bd9Sstevel@tonic-gate 27807c478bd9Sstevel@tonic-gate static int 27817c478bd9Sstevel@tonic-gate nvs_xdr_nvlist(nvstream_t *nvs, nvlist_t *nvl, size_t *size) 27827c478bd9Sstevel@tonic-gate { 27837c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 27847c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 27857c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: { 27867c478bd9Sstevel@tonic-gate XDR *xdr = nvs->nvs_private; 27877c478bd9Sstevel@tonic-gate 27887c478bd9Sstevel@tonic-gate if (!xdr_int(xdr, &nvl->nvl_version) || 27897c478bd9Sstevel@tonic-gate !xdr_u_int(xdr, &nvl->nvl_nvflag)) 27907c478bd9Sstevel@tonic-gate return (EFAULT); 27917c478bd9Sstevel@tonic-gate break; 27927c478bd9Sstevel@tonic-gate } 27937c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: { 27947c478bd9Sstevel@tonic-gate /* 27957c478bd9Sstevel@tonic-gate * 2 * 4 for nvl_version + nvl_nvflag 27967c478bd9Sstevel@tonic-gate * and 8 for end of the entire list 27977c478bd9Sstevel@tonic-gate */ 27987c478bd9Sstevel@tonic-gate *size += 2 * 4 + 8; 27997c478bd9Sstevel@tonic-gate break; 28007c478bd9Sstevel@tonic-gate } 28017c478bd9Sstevel@tonic-gate default: 28027c478bd9Sstevel@tonic-gate return (EINVAL); 28037c478bd9Sstevel@tonic-gate } 28047c478bd9Sstevel@tonic-gate return (0); 28057c478bd9Sstevel@tonic-gate } 28067c478bd9Sstevel@tonic-gate 28077c478bd9Sstevel@tonic-gate static int 28087c478bd9Sstevel@tonic-gate nvs_xdr_nvl_fini(nvstream_t *nvs) 28097c478bd9Sstevel@tonic-gate { 28107c478bd9Sstevel@tonic-gate if (nvs->nvs_op == NVS_OP_ENCODE) { 28117c478bd9Sstevel@tonic-gate XDR *xdr = nvs->nvs_private; 28127c478bd9Sstevel@tonic-gate int zero = 0; 28137c478bd9Sstevel@tonic-gate 28147c478bd9Sstevel@tonic-gate if (!xdr_int(xdr, &zero) || !xdr_int(xdr, &zero)) 28157c478bd9Sstevel@tonic-gate return (EFAULT); 28167c478bd9Sstevel@tonic-gate } 28177c478bd9Sstevel@tonic-gate 28187c478bd9Sstevel@tonic-gate return (0); 28197c478bd9Sstevel@tonic-gate } 28207c478bd9Sstevel@tonic-gate 28217c478bd9Sstevel@tonic-gate /* 28227c478bd9Sstevel@tonic-gate * The format of xdr encoded nvpair is: 28237c478bd9Sstevel@tonic-gate * encode_size, decode_size, name string, data type, nelem, data 28247c478bd9Sstevel@tonic-gate */ 28257c478bd9Sstevel@tonic-gate static int 28267c478bd9Sstevel@tonic-gate nvs_xdr_nvp_op(nvstream_t *nvs, nvpair_t *nvp) 28277c478bd9Sstevel@tonic-gate { 28287c478bd9Sstevel@tonic-gate data_type_t type; 28297c478bd9Sstevel@tonic-gate char *buf; 28307c478bd9Sstevel@tonic-gate char *buf_end = (char *)nvp + nvp->nvp_size; 28317c478bd9Sstevel@tonic-gate int value_sz; 28327c478bd9Sstevel@tonic-gate uint_t nelem, buflen; 28337c478bd9Sstevel@tonic-gate bool_t ret = FALSE; 28347c478bd9Sstevel@tonic-gate XDR *xdr = nvs->nvs_private; 28357c478bd9Sstevel@tonic-gate 28367c478bd9Sstevel@tonic-gate ASSERT(xdr != NULL && nvp != NULL); 28377c478bd9Sstevel@tonic-gate 28387c478bd9Sstevel@tonic-gate /* name string */ 28397c478bd9Sstevel@tonic-gate if ((buf = NVP_NAME(nvp)) >= buf_end) 28407c478bd9Sstevel@tonic-gate return (EFAULT); 28417c478bd9Sstevel@tonic-gate buflen = buf_end - buf; 28427c478bd9Sstevel@tonic-gate 28437c478bd9Sstevel@tonic-gate if (!xdr_string(xdr, &buf, buflen - 1)) 28447c478bd9Sstevel@tonic-gate return (EFAULT); 28457c478bd9Sstevel@tonic-gate nvp->nvp_name_sz = strlen(buf) + 1; 28467c478bd9Sstevel@tonic-gate 28477c478bd9Sstevel@tonic-gate /* type and nelem */ 28487c478bd9Sstevel@tonic-gate if (!xdr_int(xdr, (int *)&nvp->nvp_type) || 28497c478bd9Sstevel@tonic-gate !xdr_int(xdr, &nvp->nvp_value_elem)) 28507c478bd9Sstevel@tonic-gate return (EFAULT); 28517c478bd9Sstevel@tonic-gate 28527c478bd9Sstevel@tonic-gate type = NVP_TYPE(nvp); 28537c478bd9Sstevel@tonic-gate nelem = nvp->nvp_value_elem; 28547c478bd9Sstevel@tonic-gate 28557c478bd9Sstevel@tonic-gate /* 28567c478bd9Sstevel@tonic-gate * Verify type and nelem and get the value size. 28577c478bd9Sstevel@tonic-gate * In case of data types DATA_TYPE_STRING and DATA_TYPE_STRING_ARRAY 28587c478bd9Sstevel@tonic-gate * is the size of the string(s) excluded. 28597c478bd9Sstevel@tonic-gate */ 28607c478bd9Sstevel@tonic-gate if ((value_sz = i_get_value_size(type, NULL, nelem)) < 0) 28617c478bd9Sstevel@tonic-gate return (EFAULT); 28627c478bd9Sstevel@tonic-gate 28637c478bd9Sstevel@tonic-gate /* if there is no data to extract then return */ 28647c478bd9Sstevel@tonic-gate if (nelem == 0) 28657c478bd9Sstevel@tonic-gate return (0); 28667c478bd9Sstevel@tonic-gate 28677c478bd9Sstevel@tonic-gate /* value */ 28687c478bd9Sstevel@tonic-gate if ((buf = NVP_VALUE(nvp)) >= buf_end) 28697c478bd9Sstevel@tonic-gate return (EFAULT); 28707c478bd9Sstevel@tonic-gate buflen = buf_end - buf; 28717c478bd9Sstevel@tonic-gate 28727c478bd9Sstevel@tonic-gate if (buflen < value_sz) 28737c478bd9Sstevel@tonic-gate return (EFAULT); 28747c478bd9Sstevel@tonic-gate 28757c478bd9Sstevel@tonic-gate switch (type) { 28767c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 28777c478bd9Sstevel@tonic-gate if (nvs_embedded(nvs, (void *)buf) == 0) 28787c478bd9Sstevel@tonic-gate return (0); 28797c478bd9Sstevel@tonic-gate break; 28807c478bd9Sstevel@tonic-gate 28817c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: 28827c478bd9Sstevel@tonic-gate if (nvs_embedded_nvl_array(nvs, nvp, NULL) == 0) 28837c478bd9Sstevel@tonic-gate return (0); 28847c478bd9Sstevel@tonic-gate break; 28857c478bd9Sstevel@tonic-gate 28867c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 28877c478bd9Sstevel@tonic-gate ret = TRUE; 28887c478bd9Sstevel@tonic-gate break; 28897c478bd9Sstevel@tonic-gate 28907c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE: 28917c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8: 28927c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8: 28937c478bd9Sstevel@tonic-gate ret = xdr_char(xdr, buf); 28947c478bd9Sstevel@tonic-gate break; 28957c478bd9Sstevel@tonic-gate 28967c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16: 28977c478bd9Sstevel@tonic-gate ret = xdr_short(xdr, (void *)buf); 28987c478bd9Sstevel@tonic-gate break; 28997c478bd9Sstevel@tonic-gate 29007c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16: 29017c478bd9Sstevel@tonic-gate ret = xdr_u_short(xdr, (void *)buf); 29027c478bd9Sstevel@tonic-gate break; 29037c478bd9Sstevel@tonic-gate 29047c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 29057c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32: 29067c478bd9Sstevel@tonic-gate ret = xdr_int(xdr, (void *)buf); 29077c478bd9Sstevel@tonic-gate break; 29087c478bd9Sstevel@tonic-gate 29097c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32: 29107c478bd9Sstevel@tonic-gate ret = xdr_u_int(xdr, (void *)buf); 29117c478bd9Sstevel@tonic-gate break; 29127c478bd9Sstevel@tonic-gate 29137c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64: 29147c478bd9Sstevel@tonic-gate ret = xdr_longlong_t(xdr, (void *)buf); 29157c478bd9Sstevel@tonic-gate break; 29167c478bd9Sstevel@tonic-gate 29177c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64: 29187c478bd9Sstevel@tonic-gate ret = xdr_u_longlong_t(xdr, (void *)buf); 29197c478bd9Sstevel@tonic-gate break; 29207c478bd9Sstevel@tonic-gate 29217c478bd9Sstevel@tonic-gate case DATA_TYPE_HRTIME: 29227c478bd9Sstevel@tonic-gate /* 29237c478bd9Sstevel@tonic-gate * NOTE: must expose the definition of hrtime_t here 29247c478bd9Sstevel@tonic-gate */ 29257c478bd9Sstevel@tonic-gate ret = xdr_longlong_t(xdr, (void *)buf); 29267c478bd9Sstevel@tonic-gate break; 29277c478bd9Sstevel@tonic-gate 29287c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING: 29297c478bd9Sstevel@tonic-gate ret = xdr_string(xdr, &buf, buflen - 1); 29307c478bd9Sstevel@tonic-gate break; 29317c478bd9Sstevel@tonic-gate 29327c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE_ARRAY: 29337c478bd9Sstevel@tonic-gate ret = xdr_opaque(xdr, buf, nelem); 29347c478bd9Sstevel@tonic-gate break; 29357c478bd9Sstevel@tonic-gate 29367c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8_ARRAY: 29377c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8_ARRAY: 29387c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen, sizeof (int8_t), 29397c478bd9Sstevel@tonic-gate (xdrproc_t)xdr_char); 29407c478bd9Sstevel@tonic-gate break; 29417c478bd9Sstevel@tonic-gate 29427c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16_ARRAY: 29437c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (int16_t), 29447c478bd9Sstevel@tonic-gate sizeof (int16_t), (xdrproc_t)xdr_short); 29457c478bd9Sstevel@tonic-gate break; 29467c478bd9Sstevel@tonic-gate 29477c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16_ARRAY: 29487c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (uint16_t), 29497c478bd9Sstevel@tonic-gate sizeof (uint16_t), (xdrproc_t)xdr_u_short); 29507c478bd9Sstevel@tonic-gate break; 29517c478bd9Sstevel@tonic-gate 29527c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: 29537c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32_ARRAY: 29547c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (int32_t), 29557c478bd9Sstevel@tonic-gate sizeof (int32_t), (xdrproc_t)xdr_int); 29567c478bd9Sstevel@tonic-gate break; 29577c478bd9Sstevel@tonic-gate 29587c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32_ARRAY: 29597c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (uint32_t), 29607c478bd9Sstevel@tonic-gate sizeof (uint32_t), (xdrproc_t)xdr_u_int); 29617c478bd9Sstevel@tonic-gate break; 29627c478bd9Sstevel@tonic-gate 29637c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64_ARRAY: 29647c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (int64_t), 29657c478bd9Sstevel@tonic-gate sizeof (int64_t), (xdrproc_t)xdr_longlong_t); 29667c478bd9Sstevel@tonic-gate break; 29677c478bd9Sstevel@tonic-gate 29687c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64_ARRAY: 29697c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (uint64_t), 29707c478bd9Sstevel@tonic-gate sizeof (uint64_t), (xdrproc_t)xdr_u_longlong_t); 29717c478bd9Sstevel@tonic-gate break; 29727c478bd9Sstevel@tonic-gate 29737c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: { 29747c478bd9Sstevel@tonic-gate size_t len = nelem * sizeof (uint64_t); 29757c478bd9Sstevel@tonic-gate char **strp = (void *)buf; 29767c478bd9Sstevel@tonic-gate int i; 29777c478bd9Sstevel@tonic-gate 29787c478bd9Sstevel@tonic-gate if (nvs->nvs_op == NVS_OP_DECODE) 29797c478bd9Sstevel@tonic-gate bzero(buf, len); /* don't trust packed data */ 29807c478bd9Sstevel@tonic-gate 29817c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 29827c478bd9Sstevel@tonic-gate if (buflen <= len) 29837c478bd9Sstevel@tonic-gate return (EFAULT); 29847c478bd9Sstevel@tonic-gate 29857c478bd9Sstevel@tonic-gate buf += len; 29867c478bd9Sstevel@tonic-gate buflen -= len; 29877c478bd9Sstevel@tonic-gate 29887c478bd9Sstevel@tonic-gate if (xdr_string(xdr, &buf, buflen - 1) != TRUE) 29897c478bd9Sstevel@tonic-gate return (EFAULT); 29907c478bd9Sstevel@tonic-gate 29917c478bd9Sstevel@tonic-gate if (nvs->nvs_op == NVS_OP_DECODE) 29927c478bd9Sstevel@tonic-gate strp[i] = buf; 29937c478bd9Sstevel@tonic-gate len = strlen(buf) + 1; 29947c478bd9Sstevel@tonic-gate } 29957c478bd9Sstevel@tonic-gate ret = TRUE; 29967c478bd9Sstevel@tonic-gate break; 29977c478bd9Sstevel@tonic-gate } 29987c478bd9Sstevel@tonic-gate default: 29997c478bd9Sstevel@tonic-gate break; 30007c478bd9Sstevel@tonic-gate } 30017c478bd9Sstevel@tonic-gate 30027c478bd9Sstevel@tonic-gate return (ret == TRUE ? 0 : EFAULT); 30037c478bd9Sstevel@tonic-gate } 30047c478bd9Sstevel@tonic-gate 30057c478bd9Sstevel@tonic-gate static int 30067c478bd9Sstevel@tonic-gate nvs_xdr_nvp_size(nvstream_t *nvs, nvpair_t *nvp, size_t *size) 30077c478bd9Sstevel@tonic-gate { 30087c478bd9Sstevel@tonic-gate data_type_t type = NVP_TYPE(nvp); 30097c478bd9Sstevel@tonic-gate /* 30107c478bd9Sstevel@tonic-gate * encode_size + decode_size + name string size + data type + nelem 30117c478bd9Sstevel@tonic-gate * where name string size = 4 + NV_ALIGN4(strlen(NVP_NAME(nvp))) 30127c478bd9Sstevel@tonic-gate */ 30137c478bd9Sstevel@tonic-gate uint64_t nvp_sz = 4 + 4 + 4 + NV_ALIGN4(strlen(NVP_NAME(nvp))) + 4 + 4; 30147c478bd9Sstevel@tonic-gate 30157c478bd9Sstevel@tonic-gate switch (type) { 30167c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 30177c478bd9Sstevel@tonic-gate break; 30187c478bd9Sstevel@tonic-gate 30197c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 30207c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE: 30217c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8: 30227c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8: 30237c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16: 30247c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16: 30257c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32: 30267c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32: 30277c478bd9Sstevel@tonic-gate nvp_sz += 4; /* 4 is the minimum xdr unit */ 30287c478bd9Sstevel@tonic-gate break; 30297c478bd9Sstevel@tonic-gate 30307c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64: 30317c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64: 30327c478bd9Sstevel@tonic-gate case DATA_TYPE_HRTIME: 30337c478bd9Sstevel@tonic-gate nvp_sz += 8; 30347c478bd9Sstevel@tonic-gate break; 30357c478bd9Sstevel@tonic-gate 30367c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING: 30377c478bd9Sstevel@tonic-gate nvp_sz += 4 + NV_ALIGN4(strlen((char *)NVP_VALUE(nvp))); 30387c478bd9Sstevel@tonic-gate break; 30397c478bd9Sstevel@tonic-gate 30407c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE_ARRAY: 30417c478bd9Sstevel@tonic-gate nvp_sz += NV_ALIGN4(NVP_NELEM(nvp)); 30427c478bd9Sstevel@tonic-gate break; 30437c478bd9Sstevel@tonic-gate 30447c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: 30457c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8_ARRAY: 30467c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8_ARRAY: 30477c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16_ARRAY: 30487c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16_ARRAY: 30497c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32_ARRAY: 30507c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32_ARRAY: 30517c478bd9Sstevel@tonic-gate nvp_sz += 4 + 4 * (uint64_t)NVP_NELEM(nvp); 30527c478bd9Sstevel@tonic-gate break; 30537c478bd9Sstevel@tonic-gate 30547c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64_ARRAY: 30557c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64_ARRAY: 30567c478bd9Sstevel@tonic-gate nvp_sz += 4 + 8 * (uint64_t)NVP_NELEM(nvp); 30577c478bd9Sstevel@tonic-gate break; 30587c478bd9Sstevel@tonic-gate 30597c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: { 30607c478bd9Sstevel@tonic-gate int i; 30617c478bd9Sstevel@tonic-gate char **strs = (void *)NVP_VALUE(nvp); 30627c478bd9Sstevel@tonic-gate 30637c478bd9Sstevel@tonic-gate for (i = 0; i < NVP_NELEM(nvp); i++) 30647c478bd9Sstevel@tonic-gate nvp_sz += 4 + NV_ALIGN4(strlen(strs[i])); 30657c478bd9Sstevel@tonic-gate 30667c478bd9Sstevel@tonic-gate break; 30677c478bd9Sstevel@tonic-gate } 30687c478bd9Sstevel@tonic-gate 30697c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 30707c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: { 30717c478bd9Sstevel@tonic-gate size_t nvsize = 0; 30727c478bd9Sstevel@tonic-gate int old_nvs_op = nvs->nvs_op; 30737c478bd9Sstevel@tonic-gate int err; 30747c478bd9Sstevel@tonic-gate 30757c478bd9Sstevel@tonic-gate nvs->nvs_op = NVS_OP_GETSIZE; 30767c478bd9Sstevel@tonic-gate if (type == DATA_TYPE_NVLIST) 30777c478bd9Sstevel@tonic-gate err = nvs_operation(nvs, EMBEDDED_NVL(nvp), &nvsize); 30787c478bd9Sstevel@tonic-gate else 30797c478bd9Sstevel@tonic-gate err = nvs_embedded_nvl_array(nvs, nvp, &nvsize); 30807c478bd9Sstevel@tonic-gate nvs->nvs_op = old_nvs_op; 30817c478bd9Sstevel@tonic-gate 30827c478bd9Sstevel@tonic-gate if (err != 0) 30837c478bd9Sstevel@tonic-gate return (EINVAL); 30847c478bd9Sstevel@tonic-gate 30857c478bd9Sstevel@tonic-gate nvp_sz += nvsize; 30867c478bd9Sstevel@tonic-gate break; 30877c478bd9Sstevel@tonic-gate } 30887c478bd9Sstevel@tonic-gate 30897c478bd9Sstevel@tonic-gate default: 30907c478bd9Sstevel@tonic-gate return (EINVAL); 30917c478bd9Sstevel@tonic-gate } 30927c478bd9Sstevel@tonic-gate 30937c478bd9Sstevel@tonic-gate if (nvp_sz > INT32_MAX) 30947c478bd9Sstevel@tonic-gate return (EINVAL); 30957c478bd9Sstevel@tonic-gate 30967c478bd9Sstevel@tonic-gate *size = nvp_sz; 30977c478bd9Sstevel@tonic-gate 30987c478bd9Sstevel@tonic-gate return (0); 30997c478bd9Sstevel@tonic-gate } 31007c478bd9Sstevel@tonic-gate 31017c478bd9Sstevel@tonic-gate 31027c478bd9Sstevel@tonic-gate /* 31037c478bd9Sstevel@tonic-gate * The NVS_XDR_MAX_LEN macro takes a packed xdr buffer of size x and estimates 31047c478bd9Sstevel@tonic-gate * the largest nvpair that could be encoded in the buffer. 31057c478bd9Sstevel@tonic-gate * 31067c478bd9Sstevel@tonic-gate * See comments above nvpair_xdr_op() for the format of xdr encoding. 31077c478bd9Sstevel@tonic-gate * The size of a xdr packed nvpair without any data is 5 words. 31087c478bd9Sstevel@tonic-gate * 31097c478bd9Sstevel@tonic-gate * Using the size of the data directly as an estimate would be ok 31107c478bd9Sstevel@tonic-gate * in all cases except one. If the data type is of DATA_TYPE_STRING_ARRAY 31117c478bd9Sstevel@tonic-gate * then the actual nvpair has space for an array of pointers to index 31127c478bd9Sstevel@tonic-gate * the strings. These pointers are not encoded into the packed xdr buffer. 31137c478bd9Sstevel@tonic-gate * 31147c478bd9Sstevel@tonic-gate * If the data is of type DATA_TYPE_STRING_ARRAY and all the strings are 31157c478bd9Sstevel@tonic-gate * of length 0, then each string is endcoded in xdr format as a single word. 31167c478bd9Sstevel@tonic-gate * Therefore when expanded to an nvpair there will be 2.25 word used for 31177c478bd9Sstevel@tonic-gate * each string. (a int64_t allocated for pointer usage, and a single char 31187c478bd9Sstevel@tonic-gate * for the null termination.) 31197c478bd9Sstevel@tonic-gate * 31207c478bd9Sstevel@tonic-gate * This is the calculation performed by the NVS_XDR_MAX_LEN macro. 31217c478bd9Sstevel@tonic-gate */ 31227c478bd9Sstevel@tonic-gate #define NVS_XDR_HDR_LEN ((size_t)(5 * 4)) 31237c478bd9Sstevel@tonic-gate #define NVS_XDR_DATA_LEN(y) (((size_t)(y) <= NVS_XDR_HDR_LEN) ? \ 31247c478bd9Sstevel@tonic-gate 0 : ((size_t)(y) - NVS_XDR_HDR_LEN)) 31257c478bd9Sstevel@tonic-gate #define NVS_XDR_MAX_LEN(x) (NVP_SIZE_CALC(1, 0) + \ 31267c478bd9Sstevel@tonic-gate (NVS_XDR_DATA_LEN(x) * 2) + \ 31277c478bd9Sstevel@tonic-gate NV_ALIGN4((NVS_XDR_DATA_LEN(x) / 4))) 31287c478bd9Sstevel@tonic-gate 31297c478bd9Sstevel@tonic-gate static int 31307c478bd9Sstevel@tonic-gate nvs_xdr_nvpair(nvstream_t *nvs, nvpair_t *nvp, size_t *size) 31317c478bd9Sstevel@tonic-gate { 31327c478bd9Sstevel@tonic-gate XDR *xdr = nvs->nvs_private; 31337c478bd9Sstevel@tonic-gate int32_t encode_len, decode_len; 31347c478bd9Sstevel@tonic-gate 31357c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 31367c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: { 31377c478bd9Sstevel@tonic-gate size_t nvsize; 31387c478bd9Sstevel@tonic-gate 31397c478bd9Sstevel@tonic-gate if (nvs_xdr_nvp_size(nvs, nvp, &nvsize) != 0) 31407c478bd9Sstevel@tonic-gate return (EFAULT); 31417c478bd9Sstevel@tonic-gate 31427c478bd9Sstevel@tonic-gate decode_len = nvp->nvp_size; 31437c478bd9Sstevel@tonic-gate encode_len = nvsize; 31447c478bd9Sstevel@tonic-gate if (!xdr_int(xdr, &encode_len) || !xdr_int(xdr, &decode_len)) 31457c478bd9Sstevel@tonic-gate return (EFAULT); 31467c478bd9Sstevel@tonic-gate 31477c478bd9Sstevel@tonic-gate return (nvs_xdr_nvp_op(nvs, nvp)); 31487c478bd9Sstevel@tonic-gate } 31497c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: { 31507c478bd9Sstevel@tonic-gate struct xdr_bytesrec bytesrec; 31517c478bd9Sstevel@tonic-gate 31527c478bd9Sstevel@tonic-gate /* get the encode and decode size */ 31537c478bd9Sstevel@tonic-gate if (!xdr_int(xdr, &encode_len) || !xdr_int(xdr, &decode_len)) 31547c478bd9Sstevel@tonic-gate return (EFAULT); 31557c478bd9Sstevel@tonic-gate *size = decode_len; 31567c478bd9Sstevel@tonic-gate 31577c478bd9Sstevel@tonic-gate /* are we at the end of the stream? */ 31587c478bd9Sstevel@tonic-gate if (*size == 0) 31597c478bd9Sstevel@tonic-gate return (0); 31607c478bd9Sstevel@tonic-gate 31617c478bd9Sstevel@tonic-gate /* sanity check the size parameter */ 31627c478bd9Sstevel@tonic-gate if (!xdr_control(xdr, XDR_GET_BYTES_AVAIL, &bytesrec)) 31637c478bd9Sstevel@tonic-gate return (EFAULT); 31647c478bd9Sstevel@tonic-gate 31657c478bd9Sstevel@tonic-gate if (*size > NVS_XDR_MAX_LEN(bytesrec.xc_num_avail)) 31667c478bd9Sstevel@tonic-gate return (EFAULT); 31677c478bd9Sstevel@tonic-gate break; 31687c478bd9Sstevel@tonic-gate } 31697c478bd9Sstevel@tonic-gate 31707c478bd9Sstevel@tonic-gate default: 31717c478bd9Sstevel@tonic-gate return (EINVAL); 31727c478bd9Sstevel@tonic-gate } 31737c478bd9Sstevel@tonic-gate return (0); 31747c478bd9Sstevel@tonic-gate } 31757c478bd9Sstevel@tonic-gate 31767c478bd9Sstevel@tonic-gate static const struct nvs_ops nvs_xdr_ops = { 31777c478bd9Sstevel@tonic-gate nvs_xdr_nvlist, 31787c478bd9Sstevel@tonic-gate nvs_xdr_nvpair, 31797c478bd9Sstevel@tonic-gate nvs_xdr_nvp_op, 31807c478bd9Sstevel@tonic-gate nvs_xdr_nvp_size, 31817c478bd9Sstevel@tonic-gate nvs_xdr_nvl_fini 31827c478bd9Sstevel@tonic-gate }; 31837c478bd9Sstevel@tonic-gate 31847c478bd9Sstevel@tonic-gate static int 31857c478bd9Sstevel@tonic-gate nvs_xdr(nvstream_t *nvs, nvlist_t *nvl, char *buf, size_t *buflen) 31867c478bd9Sstevel@tonic-gate { 31877c478bd9Sstevel@tonic-gate XDR xdr; 31887c478bd9Sstevel@tonic-gate int err; 31897c478bd9Sstevel@tonic-gate 31907c478bd9Sstevel@tonic-gate nvs->nvs_ops = &nvs_xdr_ops; 31917c478bd9Sstevel@tonic-gate 31927c478bd9Sstevel@tonic-gate if ((err = nvs_xdr_create(nvs, &xdr, buf + sizeof (nvs_header_t), 31937c478bd9Sstevel@tonic-gate *buflen - sizeof (nvs_header_t))) != 0) 31947c478bd9Sstevel@tonic-gate return (err); 31957c478bd9Sstevel@tonic-gate 31967c478bd9Sstevel@tonic-gate err = nvs_operation(nvs, nvl, buflen); 31977c478bd9Sstevel@tonic-gate 31987c478bd9Sstevel@tonic-gate nvs_xdr_destroy(nvs); 31997c478bd9Sstevel@tonic-gate 32007c478bd9Sstevel@tonic-gate return (err); 32017c478bd9Sstevel@tonic-gate } 3202