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 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 22*d9638e54Smws 237c478bd9Sstevel@tonic-gate /* 24*d9638e54Smws * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 257c478bd9Sstevel@tonic-gate * Use is subject to license terms. 267c478bd9Sstevel@tonic-gate */ 277c478bd9Sstevel@tonic-gate 287c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate #include <sys/stropts.h> 317c478bd9Sstevel@tonic-gate #include <sys/debug.h> 327c478bd9Sstevel@tonic-gate #include <sys/isa_defs.h> 337c478bd9Sstevel@tonic-gate #include <sys/int_limits.h> 347c478bd9Sstevel@tonic-gate #include <sys/nvpair.h> 357c478bd9Sstevel@tonic-gate #include <sys/nvpair_impl.h> 367c478bd9Sstevel@tonic-gate #include <rpc/types.h> 377c478bd9Sstevel@tonic-gate #include <rpc/xdr.h> 387c478bd9Sstevel@tonic-gate 397c478bd9Sstevel@tonic-gate #if defined(_KERNEL) && !defined(_BOOT) 407c478bd9Sstevel@tonic-gate #include <sys/varargs.h> 417c478bd9Sstevel@tonic-gate #else 427c478bd9Sstevel@tonic-gate #include <stdarg.h> 437c478bd9Sstevel@tonic-gate #include <strings.h> 447c478bd9Sstevel@tonic-gate #endif 457c478bd9Sstevel@tonic-gate 467c478bd9Sstevel@tonic-gate #ifndef offsetof 477c478bd9Sstevel@tonic-gate #define offsetof(s, m) ((size_t)(&(((s *)0)->m))) 487c478bd9Sstevel@tonic-gate #endif 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate 517c478bd9Sstevel@tonic-gate /* 527c478bd9Sstevel@tonic-gate * nvpair.c - Provides kernel & userland interfaces for manipulating 537c478bd9Sstevel@tonic-gate * name-value pairs. 547c478bd9Sstevel@tonic-gate * 557c478bd9Sstevel@tonic-gate * Overview Diagram 567c478bd9Sstevel@tonic-gate * 577c478bd9Sstevel@tonic-gate * +--------------+ 587c478bd9Sstevel@tonic-gate * | nvlist_t | 597c478bd9Sstevel@tonic-gate * |--------------| 607c478bd9Sstevel@tonic-gate * | nvl_version | 617c478bd9Sstevel@tonic-gate * | nvl_nvflag | 627c478bd9Sstevel@tonic-gate * | nvl_priv -+-+ 637c478bd9Sstevel@tonic-gate * | nvl_flag | | 647c478bd9Sstevel@tonic-gate * | nvl_pad | | 657c478bd9Sstevel@tonic-gate * +--------------+ | 667c478bd9Sstevel@tonic-gate * V 677c478bd9Sstevel@tonic-gate * +--------------+ last i_nvp in list 687c478bd9Sstevel@tonic-gate * | nvpriv_t | +---------------------> 697c478bd9Sstevel@tonic-gate * |--------------| | 707c478bd9Sstevel@tonic-gate * +--+- nvp_list | | +------------+ 717c478bd9Sstevel@tonic-gate * | | nvp_last -+--+ + nv_alloc_t | 727c478bd9Sstevel@tonic-gate * | | nvp_curr | |------------| 737c478bd9Sstevel@tonic-gate * | | nvp_nva -+----> | nva_ops | 747c478bd9Sstevel@tonic-gate * | | nvp_stat | | nva_arg | 757c478bd9Sstevel@tonic-gate * | +--------------+ +------------+ 767c478bd9Sstevel@tonic-gate * | 777c478bd9Sstevel@tonic-gate * +-------+ 787c478bd9Sstevel@tonic-gate * V 797c478bd9Sstevel@tonic-gate * +---------------------+ +-------------------+ 807c478bd9Sstevel@tonic-gate * | i_nvp_t | +-->| i_nvp_t | +--> 817c478bd9Sstevel@tonic-gate * |---------------------| | |-------------------| | 827c478bd9Sstevel@tonic-gate * | nvi_next -+--+ | nvi_next -+--+ 837c478bd9Sstevel@tonic-gate * | nvi_prev (NULL) | <----+ nvi_prev | 847c478bd9Sstevel@tonic-gate * | . . . . . . . . . . | | . . . . . . . . . | 857c478bd9Sstevel@tonic-gate * | nvp (nvpair_t) | | nvp (nvpair_t) | 867c478bd9Sstevel@tonic-gate * | - nvp_size | | - nvp_size | 877c478bd9Sstevel@tonic-gate * | - nvp_name_sz | | - nvp_name_sz | 887c478bd9Sstevel@tonic-gate * | - nvp_value_elem | | - nvp_value_elem | 897c478bd9Sstevel@tonic-gate * | - nvp_type | | - nvp_type | 907c478bd9Sstevel@tonic-gate * | - data ... | | - data ... | 917c478bd9Sstevel@tonic-gate * +---------------------+ +-------------------+ 927c478bd9Sstevel@tonic-gate * 937c478bd9Sstevel@tonic-gate * 947c478bd9Sstevel@tonic-gate * 957c478bd9Sstevel@tonic-gate * +---------------------+ +---------------------+ 967c478bd9Sstevel@tonic-gate * | i_nvp_t | +--> +-->| i_nvp_t (last) | 977c478bd9Sstevel@tonic-gate * |---------------------| | | |---------------------| 987c478bd9Sstevel@tonic-gate * | nvi_next -+--+ ... --+ | nvi_next (NULL) | 997c478bd9Sstevel@tonic-gate * <-+- nvi_prev |<-- ... <----+ nvi_prev | 1007c478bd9Sstevel@tonic-gate * | . . . . . . . . . | | . . . . . . . . . | 1017c478bd9Sstevel@tonic-gate * | nvp (nvpair_t) | | nvp (nvpair_t) | 1027c478bd9Sstevel@tonic-gate * | - nvp_size | | - nvp_size | 1037c478bd9Sstevel@tonic-gate * | - nvp_name_sz | | - nvp_name_sz | 1047c478bd9Sstevel@tonic-gate * | - nvp_value_elem | | - nvp_value_elem | 1057c478bd9Sstevel@tonic-gate * | - DATA_TYPE_NVLIST | | - nvp_type | 1067c478bd9Sstevel@tonic-gate * | - data (embedded) | | - data ... | 1077c478bd9Sstevel@tonic-gate * | nvlist name | +---------------------+ 1087c478bd9Sstevel@tonic-gate * | +--------------+ | 1097c478bd9Sstevel@tonic-gate * | | nvlist_t | | 1107c478bd9Sstevel@tonic-gate * | |--------------| | 1117c478bd9Sstevel@tonic-gate * | | nvl_version | | 1127c478bd9Sstevel@tonic-gate * | | nvl_nvflag | | 1137c478bd9Sstevel@tonic-gate * | | nvl_priv --+---+----> 1147c478bd9Sstevel@tonic-gate * | | nvl_flag | | 1157c478bd9Sstevel@tonic-gate * | | nvl_pad | | 1167c478bd9Sstevel@tonic-gate * | +--------------+ | 1177c478bd9Sstevel@tonic-gate * +---------------------+ 1187c478bd9Sstevel@tonic-gate * 1197c478bd9Sstevel@tonic-gate * 1207c478bd9Sstevel@tonic-gate * N.B. nvpair_t may be aligned on 4 byte boundary, so +4 will 1217c478bd9Sstevel@tonic-gate * allow value to be aligned on 8 byte boundary 1227c478bd9Sstevel@tonic-gate * 1237c478bd9Sstevel@tonic-gate * name_len is the length of the name string including the null terminator 1247c478bd9Sstevel@tonic-gate * so it must be >= 1 1257c478bd9Sstevel@tonic-gate */ 1267c478bd9Sstevel@tonic-gate #define NVP_SIZE_CALC(name_len, data_len) \ 1277c478bd9Sstevel@tonic-gate (NV_ALIGN((sizeof (nvpair_t)) + name_len) + NV_ALIGN(data_len)) 1287c478bd9Sstevel@tonic-gate 1297c478bd9Sstevel@tonic-gate static int i_get_value_size(data_type_t type, const void *data, uint_t nelem); 1307c478bd9Sstevel@tonic-gate static int nvlist_add_common(nvlist_t *nvl, const char *name, data_type_t type, 1317c478bd9Sstevel@tonic-gate uint_t nelem, const void *data); 1327c478bd9Sstevel@tonic-gate 1337c478bd9Sstevel@tonic-gate #define NV_STAT_EMBEDDED 0x1 1347c478bd9Sstevel@tonic-gate #define EMBEDDED_NVL(nvp) ((nvlist_t *)(void *)NVP_VALUE(nvp)) 1357c478bd9Sstevel@tonic-gate #define EMBEDDED_NVL_ARRAY(nvp) ((nvlist_t **)(void *)NVP_VALUE(nvp)) 1367c478bd9Sstevel@tonic-gate 1377c478bd9Sstevel@tonic-gate #define NVP_VALOFF(nvp) (NV_ALIGN(sizeof (nvpair_t) + (nvp)->nvp_name_sz)) 1387c478bd9Sstevel@tonic-gate #define NVPAIR2I_NVP(nvp) \ 1397c478bd9Sstevel@tonic-gate ((i_nvp_t *)((size_t)(nvp) - offsetof(i_nvp_t, nvi_nvp))) 1407c478bd9Sstevel@tonic-gate 1417c478bd9Sstevel@tonic-gate 1427c478bd9Sstevel@tonic-gate int 1437c478bd9Sstevel@tonic-gate nv_alloc_init(nv_alloc_t *nva, const nv_alloc_ops_t *nvo, /* args */ ...) 1447c478bd9Sstevel@tonic-gate { 1457c478bd9Sstevel@tonic-gate va_list valist; 1467c478bd9Sstevel@tonic-gate int err = 0; 1477c478bd9Sstevel@tonic-gate 1487c478bd9Sstevel@tonic-gate nva->nva_ops = nvo; 1497c478bd9Sstevel@tonic-gate nva->nva_arg = NULL; 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate va_start(valist, nvo); 1527c478bd9Sstevel@tonic-gate if (nva->nva_ops->nv_ao_init != NULL) 1537c478bd9Sstevel@tonic-gate err = nva->nva_ops->nv_ao_init(nva, valist); 1547c478bd9Sstevel@tonic-gate va_end(valist); 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate return (err); 1577c478bd9Sstevel@tonic-gate } 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate void 1607c478bd9Sstevel@tonic-gate nv_alloc_reset(nv_alloc_t *nva) 1617c478bd9Sstevel@tonic-gate { 1627c478bd9Sstevel@tonic-gate if (nva->nva_ops->nv_ao_reset != NULL) 1637c478bd9Sstevel@tonic-gate nva->nva_ops->nv_ao_reset(nva); 1647c478bd9Sstevel@tonic-gate } 1657c478bd9Sstevel@tonic-gate 1667c478bd9Sstevel@tonic-gate void 1677c478bd9Sstevel@tonic-gate nv_alloc_fini(nv_alloc_t *nva) 1687c478bd9Sstevel@tonic-gate { 1697c478bd9Sstevel@tonic-gate if (nva->nva_ops->nv_ao_fini != NULL) 1707c478bd9Sstevel@tonic-gate nva->nva_ops->nv_ao_fini(nva); 1717c478bd9Sstevel@tonic-gate } 1727c478bd9Sstevel@tonic-gate 1737c478bd9Sstevel@tonic-gate nv_alloc_t * 1747c478bd9Sstevel@tonic-gate nvlist_lookup_nv_alloc(nvlist_t *nvl) 1757c478bd9Sstevel@tonic-gate { 1767c478bd9Sstevel@tonic-gate nvpriv_t *priv; 1777c478bd9Sstevel@tonic-gate 1787c478bd9Sstevel@tonic-gate if (nvl == NULL || 1797c478bd9Sstevel@tonic-gate (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 1807c478bd9Sstevel@tonic-gate return (NULL); 1817c478bd9Sstevel@tonic-gate 1827c478bd9Sstevel@tonic-gate return (priv->nvp_nva); 1837c478bd9Sstevel@tonic-gate } 1847c478bd9Sstevel@tonic-gate 1857c478bd9Sstevel@tonic-gate static void * 1867c478bd9Sstevel@tonic-gate nv_mem_zalloc(nvpriv_t *nvp, size_t size) 1877c478bd9Sstevel@tonic-gate { 1887c478bd9Sstevel@tonic-gate nv_alloc_t *nva = nvp->nvp_nva; 1897c478bd9Sstevel@tonic-gate void *buf; 1907c478bd9Sstevel@tonic-gate 1917c478bd9Sstevel@tonic-gate if ((buf = nva->nva_ops->nv_ao_alloc(nva, size)) != NULL) 1927c478bd9Sstevel@tonic-gate bzero(buf, size); 1937c478bd9Sstevel@tonic-gate 1947c478bd9Sstevel@tonic-gate return (buf); 1957c478bd9Sstevel@tonic-gate } 1967c478bd9Sstevel@tonic-gate 1977c478bd9Sstevel@tonic-gate static void 1987c478bd9Sstevel@tonic-gate nv_mem_free(nvpriv_t *nvp, void *buf, size_t size) 1997c478bd9Sstevel@tonic-gate { 2007c478bd9Sstevel@tonic-gate nv_alloc_t *nva = nvp->nvp_nva; 2017c478bd9Sstevel@tonic-gate 2027c478bd9Sstevel@tonic-gate nva->nva_ops->nv_ao_free(nva, buf, size); 2037c478bd9Sstevel@tonic-gate } 2047c478bd9Sstevel@tonic-gate 2057c478bd9Sstevel@tonic-gate static void 2067c478bd9Sstevel@tonic-gate nv_priv_init(nvpriv_t *priv, nv_alloc_t *nva, uint32_t stat) 2077c478bd9Sstevel@tonic-gate { 2087c478bd9Sstevel@tonic-gate bzero(priv, sizeof (priv)); 2097c478bd9Sstevel@tonic-gate 2107c478bd9Sstevel@tonic-gate priv->nvp_nva = nva; 2117c478bd9Sstevel@tonic-gate priv->nvp_stat = stat; 2127c478bd9Sstevel@tonic-gate } 2137c478bd9Sstevel@tonic-gate 2147c478bd9Sstevel@tonic-gate static nvpriv_t * 2157c478bd9Sstevel@tonic-gate nv_priv_alloc(nv_alloc_t *nva) 2167c478bd9Sstevel@tonic-gate { 2177c478bd9Sstevel@tonic-gate nvpriv_t *priv; 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate /* 2207c478bd9Sstevel@tonic-gate * nv_mem_alloc() cannot called here because it needs the priv 2217c478bd9Sstevel@tonic-gate * argument. 2227c478bd9Sstevel@tonic-gate */ 2237c478bd9Sstevel@tonic-gate if ((priv = nva->nva_ops->nv_ao_alloc(nva, sizeof (nvpriv_t))) == NULL) 2247c478bd9Sstevel@tonic-gate return (NULL); 2257c478bd9Sstevel@tonic-gate 2267c478bd9Sstevel@tonic-gate nv_priv_init(priv, nva, 0); 2277c478bd9Sstevel@tonic-gate 2287c478bd9Sstevel@tonic-gate return (priv); 2297c478bd9Sstevel@tonic-gate } 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate /* 2327c478bd9Sstevel@tonic-gate * Embedded lists need their own nvpriv_t's. We create a new 2337c478bd9Sstevel@tonic-gate * nvpriv_t using the parameters and allocator from the parent 2347c478bd9Sstevel@tonic-gate * list's nvpriv_t. 2357c478bd9Sstevel@tonic-gate */ 2367c478bd9Sstevel@tonic-gate static nvpriv_t * 2377c478bd9Sstevel@tonic-gate nv_priv_alloc_embedded(nvpriv_t *priv) 2387c478bd9Sstevel@tonic-gate { 2397c478bd9Sstevel@tonic-gate nvpriv_t *emb_priv; 2407c478bd9Sstevel@tonic-gate 2417c478bd9Sstevel@tonic-gate if ((emb_priv = nv_mem_zalloc(priv, sizeof (nvpriv_t))) == NULL) 2427c478bd9Sstevel@tonic-gate return (NULL); 2437c478bd9Sstevel@tonic-gate 2447c478bd9Sstevel@tonic-gate nv_priv_init(emb_priv, priv->nvp_nva, NV_STAT_EMBEDDED); 2457c478bd9Sstevel@tonic-gate 2467c478bd9Sstevel@tonic-gate return (emb_priv); 2477c478bd9Sstevel@tonic-gate } 2487c478bd9Sstevel@tonic-gate 2497c478bd9Sstevel@tonic-gate static void 2507c478bd9Sstevel@tonic-gate nvlist_init(nvlist_t *nvl, uint32_t nvflag, nvpriv_t *priv) 2517c478bd9Sstevel@tonic-gate { 2527c478bd9Sstevel@tonic-gate nvl->nvl_version = NV_VERSION; 2537c478bd9Sstevel@tonic-gate nvl->nvl_nvflag = nvflag & (NV_UNIQUE_NAME|NV_UNIQUE_NAME_TYPE); 2547c478bd9Sstevel@tonic-gate nvl->nvl_priv = (uint64_t)(uintptr_t)priv; 2557c478bd9Sstevel@tonic-gate nvl->nvl_flag = 0; 2567c478bd9Sstevel@tonic-gate nvl->nvl_pad = 0; 2577c478bd9Sstevel@tonic-gate } 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate /* 2607c478bd9Sstevel@tonic-gate * nvlist_alloc - Allocate nvlist. 2617c478bd9Sstevel@tonic-gate */ 2627c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 2637c478bd9Sstevel@tonic-gate int 2647c478bd9Sstevel@tonic-gate nvlist_alloc(nvlist_t **nvlp, uint_t nvflag, int kmflag) 2657c478bd9Sstevel@tonic-gate { 2667c478bd9Sstevel@tonic-gate #if defined(_KERNEL) && !defined(_BOOT) 2677c478bd9Sstevel@tonic-gate return (nvlist_xalloc(nvlp, nvflag, 2687c478bd9Sstevel@tonic-gate (kmflag == KM_SLEEP ? nv_alloc_sleep : nv_alloc_nosleep))); 2697c478bd9Sstevel@tonic-gate #else 2707c478bd9Sstevel@tonic-gate return (nvlist_xalloc(nvlp, nvflag, nv_alloc_nosleep)); 2717c478bd9Sstevel@tonic-gate #endif 2727c478bd9Sstevel@tonic-gate } 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate int 2757c478bd9Sstevel@tonic-gate nvlist_xalloc(nvlist_t **nvlp, uint_t nvflag, nv_alloc_t *nva) 2767c478bd9Sstevel@tonic-gate { 2777c478bd9Sstevel@tonic-gate nvpriv_t *priv; 2787c478bd9Sstevel@tonic-gate 2797c478bd9Sstevel@tonic-gate if (nvlp == NULL || nva == NULL) 2807c478bd9Sstevel@tonic-gate return (EINVAL); 2817c478bd9Sstevel@tonic-gate 2827c478bd9Sstevel@tonic-gate if ((priv = nv_priv_alloc(nva)) == NULL) 2837c478bd9Sstevel@tonic-gate return (ENOMEM); 2847c478bd9Sstevel@tonic-gate 2857c478bd9Sstevel@tonic-gate if ((*nvlp = nv_mem_zalloc(priv, 2867c478bd9Sstevel@tonic-gate NV_ALIGN(sizeof (nvlist_t)))) == NULL) { 2877c478bd9Sstevel@tonic-gate nv_mem_free(priv, priv, sizeof (nvpriv_t)); 2887c478bd9Sstevel@tonic-gate return (ENOMEM); 2897c478bd9Sstevel@tonic-gate } 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate nvlist_init(*nvlp, nvflag, priv); 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate return (0); 2947c478bd9Sstevel@tonic-gate } 2957c478bd9Sstevel@tonic-gate 2967c478bd9Sstevel@tonic-gate /* 2977c478bd9Sstevel@tonic-gate * nvp_buf_alloc - Allocate i_nvp_t for storing a new nv pair. 2987c478bd9Sstevel@tonic-gate */ 2997c478bd9Sstevel@tonic-gate static nvpair_t * 3007c478bd9Sstevel@tonic-gate nvp_buf_alloc(nvlist_t *nvl, size_t len) 3017c478bd9Sstevel@tonic-gate { 3027c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 3037c478bd9Sstevel@tonic-gate i_nvp_t *buf; 3047c478bd9Sstevel@tonic-gate nvpair_t *nvp; 3057c478bd9Sstevel@tonic-gate size_t nvsize; 3067c478bd9Sstevel@tonic-gate 3077c478bd9Sstevel@tonic-gate /* 3087c478bd9Sstevel@tonic-gate * Allocate the buffer 3097c478bd9Sstevel@tonic-gate */ 3107c478bd9Sstevel@tonic-gate nvsize = len + offsetof(i_nvp_t, nvi_nvp); 3117c478bd9Sstevel@tonic-gate 3127c478bd9Sstevel@tonic-gate if ((buf = nv_mem_zalloc(priv, nvsize)) == NULL) 3137c478bd9Sstevel@tonic-gate return (NULL); 3147c478bd9Sstevel@tonic-gate 3157c478bd9Sstevel@tonic-gate nvp = &buf->nvi_nvp; 3167c478bd9Sstevel@tonic-gate nvp->nvp_size = len; 3177c478bd9Sstevel@tonic-gate 3187c478bd9Sstevel@tonic-gate return (nvp); 3197c478bd9Sstevel@tonic-gate } 3207c478bd9Sstevel@tonic-gate 3217c478bd9Sstevel@tonic-gate /* 3227c478bd9Sstevel@tonic-gate * nvp_buf_free - de-Allocate an i_nvp_t. 3237c478bd9Sstevel@tonic-gate */ 3247c478bd9Sstevel@tonic-gate static void 3257c478bd9Sstevel@tonic-gate nvp_buf_free(nvlist_t *nvl, nvpair_t *nvp) 3267c478bd9Sstevel@tonic-gate { 3277c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 3287c478bd9Sstevel@tonic-gate size_t nvsize = nvp->nvp_size + offsetof(i_nvp_t, nvi_nvp); 3297c478bd9Sstevel@tonic-gate 3307c478bd9Sstevel@tonic-gate nv_mem_free(priv, NVPAIR2I_NVP(nvp), nvsize); 3317c478bd9Sstevel@tonic-gate } 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate /* 3347c478bd9Sstevel@tonic-gate * nvp_buf_link - link a new nv pair into the nvlist. 3357c478bd9Sstevel@tonic-gate */ 3367c478bd9Sstevel@tonic-gate static void 3377c478bd9Sstevel@tonic-gate nvp_buf_link(nvlist_t *nvl, nvpair_t *nvp) 3387c478bd9Sstevel@tonic-gate { 3397c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 3407c478bd9Sstevel@tonic-gate i_nvp_t *curr = NVPAIR2I_NVP(nvp); 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate /* Put element at end of nvlist */ 3437c478bd9Sstevel@tonic-gate if (priv->nvp_list == NULL) { 3447c478bd9Sstevel@tonic-gate priv->nvp_list = priv->nvp_last = curr; 3457c478bd9Sstevel@tonic-gate } else { 3467c478bd9Sstevel@tonic-gate curr->nvi_prev = priv->nvp_last; 3477c478bd9Sstevel@tonic-gate priv->nvp_last->nvi_next = curr; 3487c478bd9Sstevel@tonic-gate priv->nvp_last = curr; 3497c478bd9Sstevel@tonic-gate } 3507c478bd9Sstevel@tonic-gate } 3517c478bd9Sstevel@tonic-gate 3527c478bd9Sstevel@tonic-gate /* 3537c478bd9Sstevel@tonic-gate * nvp_buf_unlink - unlink an removed nvpair out of the nvlist. 3547c478bd9Sstevel@tonic-gate */ 3557c478bd9Sstevel@tonic-gate static void 3567c478bd9Sstevel@tonic-gate nvp_buf_unlink(nvlist_t *nvl, nvpair_t *nvp) 3577c478bd9Sstevel@tonic-gate { 3587c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 3597c478bd9Sstevel@tonic-gate i_nvp_t *curr = NVPAIR2I_NVP(nvp); 3607c478bd9Sstevel@tonic-gate 3617c478bd9Sstevel@tonic-gate /* 3627c478bd9Sstevel@tonic-gate * protect nvlist_next_nvpair() against walking on freed memory. 3637c478bd9Sstevel@tonic-gate */ 3647c478bd9Sstevel@tonic-gate if (priv->nvp_curr == curr) 3657c478bd9Sstevel@tonic-gate priv->nvp_curr = curr->nvi_next; 3667c478bd9Sstevel@tonic-gate 3677c478bd9Sstevel@tonic-gate if (curr == priv->nvp_list) 3687c478bd9Sstevel@tonic-gate priv->nvp_list = curr->nvi_next; 3697c478bd9Sstevel@tonic-gate else 3707c478bd9Sstevel@tonic-gate curr->nvi_prev->nvi_next = curr->nvi_next; 3717c478bd9Sstevel@tonic-gate 3727c478bd9Sstevel@tonic-gate if (curr == priv->nvp_last) 3737c478bd9Sstevel@tonic-gate priv->nvp_last = curr->nvi_prev; 3747c478bd9Sstevel@tonic-gate else 3757c478bd9Sstevel@tonic-gate curr->nvi_next->nvi_prev = curr->nvi_prev; 3767c478bd9Sstevel@tonic-gate } 3777c478bd9Sstevel@tonic-gate 3787c478bd9Sstevel@tonic-gate /* 3797c478bd9Sstevel@tonic-gate * take a nvpair type and number of elements and make sure the are valid 3807c478bd9Sstevel@tonic-gate */ 3817c478bd9Sstevel@tonic-gate static int 3827c478bd9Sstevel@tonic-gate i_validate_type_nelem(data_type_t type, uint_t nelem) 3837c478bd9Sstevel@tonic-gate { 3847c478bd9Sstevel@tonic-gate switch (type) { 3857c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 3867c478bd9Sstevel@tonic-gate if (nelem != 0) 3877c478bd9Sstevel@tonic-gate return (EINVAL); 3887c478bd9Sstevel@tonic-gate break; 3897c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 3907c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE: 3917c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8: 3927c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8: 3937c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16: 3947c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16: 3957c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32: 3967c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32: 3977c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64: 3987c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64: 3997c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING: 4007c478bd9Sstevel@tonic-gate case DATA_TYPE_HRTIME: 4017c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 4027c478bd9Sstevel@tonic-gate if (nelem != 1) 4037c478bd9Sstevel@tonic-gate return (EINVAL); 4047c478bd9Sstevel@tonic-gate break; 4057c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: 4067c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE_ARRAY: 4077c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8_ARRAY: 4087c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8_ARRAY: 4097c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16_ARRAY: 4107c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16_ARRAY: 4117c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32_ARRAY: 4127c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32_ARRAY: 4137c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64_ARRAY: 4147c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64_ARRAY: 4157c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: 4167c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: 4177c478bd9Sstevel@tonic-gate /* we allow arrays with 0 elements */ 4187c478bd9Sstevel@tonic-gate break; 4197c478bd9Sstevel@tonic-gate default: 4207c478bd9Sstevel@tonic-gate return (EINVAL); 4217c478bd9Sstevel@tonic-gate } 4227c478bd9Sstevel@tonic-gate return (0); 4237c478bd9Sstevel@tonic-gate } 4247c478bd9Sstevel@tonic-gate 4257c478bd9Sstevel@tonic-gate /* 4267c478bd9Sstevel@tonic-gate * Verify nvp_name_sz and check the name string length. 4277c478bd9Sstevel@tonic-gate */ 4287c478bd9Sstevel@tonic-gate static int 4297c478bd9Sstevel@tonic-gate i_validate_nvpair_name(nvpair_t *nvp) 4307c478bd9Sstevel@tonic-gate { 4317c478bd9Sstevel@tonic-gate if ((nvp->nvp_name_sz <= 0) || 4327c478bd9Sstevel@tonic-gate (nvp->nvp_size < NVP_SIZE_CALC(nvp->nvp_name_sz, 0))) 4337c478bd9Sstevel@tonic-gate return (EFAULT); 4347c478bd9Sstevel@tonic-gate 4357c478bd9Sstevel@tonic-gate /* verify the name string, make sure its terminated */ 4367c478bd9Sstevel@tonic-gate if (NVP_NAME(nvp)[nvp->nvp_name_sz - 1] != '\0') 4377c478bd9Sstevel@tonic-gate return (EFAULT); 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate return (strlen(NVP_NAME(nvp)) == nvp->nvp_name_sz - 1 ? 0 : EFAULT); 4407c478bd9Sstevel@tonic-gate } 4417c478bd9Sstevel@tonic-gate 4427c478bd9Sstevel@tonic-gate static int 4437c478bd9Sstevel@tonic-gate i_validate_nvpair_value(data_type_t type, uint_t nelem, const void *data) 4447c478bd9Sstevel@tonic-gate { 4457c478bd9Sstevel@tonic-gate switch (type) { 4467c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 4477c478bd9Sstevel@tonic-gate if (*(boolean_t *)data != B_TRUE && 4487c478bd9Sstevel@tonic-gate *(boolean_t *)data != B_FALSE) 4497c478bd9Sstevel@tonic-gate return (EINVAL); 4507c478bd9Sstevel@tonic-gate break; 4517c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: { 4527c478bd9Sstevel@tonic-gate int i; 4537c478bd9Sstevel@tonic-gate 4547c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) 4557c478bd9Sstevel@tonic-gate if (((boolean_t *)data)[i] != B_TRUE && 4567c478bd9Sstevel@tonic-gate ((boolean_t *)data)[i] != B_FALSE) 4577c478bd9Sstevel@tonic-gate return (EINVAL); 4587c478bd9Sstevel@tonic-gate break; 4597c478bd9Sstevel@tonic-gate } 4607c478bd9Sstevel@tonic-gate default: 4617c478bd9Sstevel@tonic-gate break; 4627c478bd9Sstevel@tonic-gate } 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate return (0); 4657c478bd9Sstevel@tonic-gate } 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate /* 4687c478bd9Sstevel@tonic-gate * This function takes a pointer to what should be a nvpair and it's size 4697c478bd9Sstevel@tonic-gate * and then verifies that all the nvpair fields make sense and can be 4707c478bd9Sstevel@tonic-gate * trusted. This function is used when decoding packed nvpairs. 4717c478bd9Sstevel@tonic-gate */ 4727c478bd9Sstevel@tonic-gate static int 4737c478bd9Sstevel@tonic-gate i_validate_nvpair(nvpair_t *nvp) 4747c478bd9Sstevel@tonic-gate { 4757c478bd9Sstevel@tonic-gate data_type_t type = NVP_TYPE(nvp); 4767c478bd9Sstevel@tonic-gate int size1, size2; 4777c478bd9Sstevel@tonic-gate 4787c478bd9Sstevel@tonic-gate /* verify nvp_name_sz, check the name string length */ 4797c478bd9Sstevel@tonic-gate if (i_validate_nvpair_name(nvp) != 0) 4807c478bd9Sstevel@tonic-gate return (EFAULT); 4817c478bd9Sstevel@tonic-gate 4827c478bd9Sstevel@tonic-gate if (i_validate_nvpair_value(type, NVP_NELEM(nvp), NVP_VALUE(nvp)) != 0) 4837c478bd9Sstevel@tonic-gate return (EFAULT); 4847c478bd9Sstevel@tonic-gate 4857c478bd9Sstevel@tonic-gate /* 4867c478bd9Sstevel@tonic-gate * verify nvp_type, nvp_value_elem, and also possibly 4877c478bd9Sstevel@tonic-gate * verify string values and get the value size. 4887c478bd9Sstevel@tonic-gate */ 4897c478bd9Sstevel@tonic-gate size2 = i_get_value_size(type, NVP_VALUE(nvp), NVP_NELEM(nvp)); 4907c478bd9Sstevel@tonic-gate size1 = nvp->nvp_size - NVP_VALOFF(nvp); 4917c478bd9Sstevel@tonic-gate if (size2 < 0 || size1 != NV_ALIGN(size2)) 4927c478bd9Sstevel@tonic-gate return (EFAULT); 4937c478bd9Sstevel@tonic-gate 4947c478bd9Sstevel@tonic-gate return (0); 4957c478bd9Sstevel@tonic-gate } 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate static int 4987c478bd9Sstevel@tonic-gate nvlist_copy_pairs(nvlist_t *snvl, nvlist_t *dnvl) 4997c478bd9Sstevel@tonic-gate { 5007c478bd9Sstevel@tonic-gate nvpriv_t *priv; 5017c478bd9Sstevel@tonic-gate i_nvp_t *curr; 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate if ((priv = (nvpriv_t *)(uintptr_t)snvl->nvl_priv) == NULL) 5047c478bd9Sstevel@tonic-gate return (EINVAL); 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) { 5077c478bd9Sstevel@tonic-gate nvpair_t *nvp = &curr->nvi_nvp; 5087c478bd9Sstevel@tonic-gate int err; 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate if ((err = nvlist_add_common(dnvl, NVP_NAME(nvp), NVP_TYPE(nvp), 5117c478bd9Sstevel@tonic-gate NVP_NELEM(nvp), NVP_VALUE(nvp))) != 0) 5127c478bd9Sstevel@tonic-gate return (err); 5137c478bd9Sstevel@tonic-gate } 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate return (0); 5167c478bd9Sstevel@tonic-gate } 5177c478bd9Sstevel@tonic-gate 5187c478bd9Sstevel@tonic-gate /* 5197c478bd9Sstevel@tonic-gate * Frees all memory allocated for an nvpair (like embedded lists) with 5207c478bd9Sstevel@tonic-gate * the exception of the nvpair buffer itself. 5217c478bd9Sstevel@tonic-gate */ 5227c478bd9Sstevel@tonic-gate static void 5237c478bd9Sstevel@tonic-gate nvpair_free(nvpair_t *nvp) 5247c478bd9Sstevel@tonic-gate { 5257c478bd9Sstevel@tonic-gate switch (NVP_TYPE(nvp)) { 5267c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 5277c478bd9Sstevel@tonic-gate nvlist_free(EMBEDDED_NVL(nvp)); 5287c478bd9Sstevel@tonic-gate break; 5297c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: { 5307c478bd9Sstevel@tonic-gate nvlist_t **nvlp = EMBEDDED_NVL_ARRAY(nvp); 5317c478bd9Sstevel@tonic-gate int i; 5327c478bd9Sstevel@tonic-gate 5337c478bd9Sstevel@tonic-gate for (i = 0; i < NVP_NELEM(nvp); i++) 5347c478bd9Sstevel@tonic-gate if (nvlp[i] != NULL) 5357c478bd9Sstevel@tonic-gate nvlist_free(nvlp[i]); 5367c478bd9Sstevel@tonic-gate break; 5377c478bd9Sstevel@tonic-gate } 5387c478bd9Sstevel@tonic-gate default: 5397c478bd9Sstevel@tonic-gate break; 5407c478bd9Sstevel@tonic-gate } 5417c478bd9Sstevel@tonic-gate } 5427c478bd9Sstevel@tonic-gate 5437c478bd9Sstevel@tonic-gate /* 5447c478bd9Sstevel@tonic-gate * nvlist_free - free an unpacked nvlist 5457c478bd9Sstevel@tonic-gate */ 5467c478bd9Sstevel@tonic-gate void 5477c478bd9Sstevel@tonic-gate nvlist_free(nvlist_t *nvl) 5487c478bd9Sstevel@tonic-gate { 5497c478bd9Sstevel@tonic-gate nvpriv_t *priv; 5507c478bd9Sstevel@tonic-gate i_nvp_t *curr; 5517c478bd9Sstevel@tonic-gate 5527c478bd9Sstevel@tonic-gate if (nvl == NULL || 5537c478bd9Sstevel@tonic-gate (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 5547c478bd9Sstevel@tonic-gate return; 5557c478bd9Sstevel@tonic-gate 5567c478bd9Sstevel@tonic-gate /* 5577c478bd9Sstevel@tonic-gate * Unpacked nvlist are linked through i_nvp_t 5587c478bd9Sstevel@tonic-gate */ 5597c478bd9Sstevel@tonic-gate curr = priv->nvp_list; 5607c478bd9Sstevel@tonic-gate while (curr != NULL) { 5617c478bd9Sstevel@tonic-gate nvpair_t *nvp = &curr->nvi_nvp; 5627c478bd9Sstevel@tonic-gate curr = curr->nvi_next; 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate nvpair_free(nvp); 5657c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 5667c478bd9Sstevel@tonic-gate } 5677c478bd9Sstevel@tonic-gate 5687c478bd9Sstevel@tonic-gate if (!(priv->nvp_stat & NV_STAT_EMBEDDED)) 5697c478bd9Sstevel@tonic-gate nv_mem_free(priv, nvl, NV_ALIGN(sizeof (nvlist_t))); 5707c478bd9Sstevel@tonic-gate else 5717c478bd9Sstevel@tonic-gate nvl->nvl_priv = NULL; 5727c478bd9Sstevel@tonic-gate 5737c478bd9Sstevel@tonic-gate nv_mem_free(priv, priv, sizeof (nvpriv_t)); 5747c478bd9Sstevel@tonic-gate } 5757c478bd9Sstevel@tonic-gate 5767c478bd9Sstevel@tonic-gate static int 5777c478bd9Sstevel@tonic-gate nvlist_contains_nvp(nvlist_t *nvl, nvpair_t *nvp) 5787c478bd9Sstevel@tonic-gate { 5797c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 5807c478bd9Sstevel@tonic-gate i_nvp_t *curr; 5817c478bd9Sstevel@tonic-gate 5827c478bd9Sstevel@tonic-gate if (nvp == NULL) 5837c478bd9Sstevel@tonic-gate return (0); 5847c478bd9Sstevel@tonic-gate 5857c478bd9Sstevel@tonic-gate for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) 5867c478bd9Sstevel@tonic-gate if (&curr->nvi_nvp == nvp) 5877c478bd9Sstevel@tonic-gate return (1); 5887c478bd9Sstevel@tonic-gate 5897c478bd9Sstevel@tonic-gate return (0); 5907c478bd9Sstevel@tonic-gate } 5917c478bd9Sstevel@tonic-gate 5927c478bd9Sstevel@tonic-gate /* 5937c478bd9Sstevel@tonic-gate * Make a copy of nvlist 5947c478bd9Sstevel@tonic-gate */ 5957c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 5967c478bd9Sstevel@tonic-gate int 5977c478bd9Sstevel@tonic-gate nvlist_dup(nvlist_t *nvl, nvlist_t **nvlp, int kmflag) 5987c478bd9Sstevel@tonic-gate { 5997c478bd9Sstevel@tonic-gate #if defined(_KERNEL) && !defined(_BOOT) 6007c478bd9Sstevel@tonic-gate return (nvlist_xdup(nvl, nvlp, 6017c478bd9Sstevel@tonic-gate (kmflag == KM_SLEEP ? nv_alloc_sleep : nv_alloc_nosleep))); 6027c478bd9Sstevel@tonic-gate #else 6037c478bd9Sstevel@tonic-gate return (nvlist_xdup(nvl, nvlp, nv_alloc_nosleep)); 6047c478bd9Sstevel@tonic-gate #endif 6057c478bd9Sstevel@tonic-gate } 6067c478bd9Sstevel@tonic-gate 6077c478bd9Sstevel@tonic-gate int 6087c478bd9Sstevel@tonic-gate nvlist_xdup(nvlist_t *nvl, nvlist_t **nvlp, nv_alloc_t *nva) 6097c478bd9Sstevel@tonic-gate { 6107c478bd9Sstevel@tonic-gate int err; 6117c478bd9Sstevel@tonic-gate 6127c478bd9Sstevel@tonic-gate if (nvl == NULL || nvlp == NULL) 6137c478bd9Sstevel@tonic-gate return (EINVAL); 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate if ((err = nvlist_xalloc(nvlp, nvl->nvl_nvflag, nva)) != 0) 6167c478bd9Sstevel@tonic-gate return (err); 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate if ((err = nvlist_copy_pairs(nvl, *nvlp)) != 0) 6197c478bd9Sstevel@tonic-gate nvlist_free(*nvlp); 6207c478bd9Sstevel@tonic-gate 6217c478bd9Sstevel@tonic-gate return (err); 6227c478bd9Sstevel@tonic-gate } 6237c478bd9Sstevel@tonic-gate 6247c478bd9Sstevel@tonic-gate /* 6257c478bd9Sstevel@tonic-gate * Remove all with matching name 6267c478bd9Sstevel@tonic-gate */ 6277c478bd9Sstevel@tonic-gate int 6287c478bd9Sstevel@tonic-gate nvlist_remove_all(nvlist_t *nvl, const char *name) 6297c478bd9Sstevel@tonic-gate { 6307c478bd9Sstevel@tonic-gate nvpriv_t *priv; 6317c478bd9Sstevel@tonic-gate i_nvp_t *curr; 6327c478bd9Sstevel@tonic-gate int error = ENOENT; 6337c478bd9Sstevel@tonic-gate 6347c478bd9Sstevel@tonic-gate if (nvl == NULL || name == NULL || 6357c478bd9Sstevel@tonic-gate (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 6367c478bd9Sstevel@tonic-gate return (EINVAL); 6377c478bd9Sstevel@tonic-gate 6387c478bd9Sstevel@tonic-gate curr = priv->nvp_list; 6397c478bd9Sstevel@tonic-gate while (curr != NULL) { 6407c478bd9Sstevel@tonic-gate nvpair_t *nvp = &curr->nvi_nvp; 6417c478bd9Sstevel@tonic-gate 6427c478bd9Sstevel@tonic-gate curr = curr->nvi_next; 6437c478bd9Sstevel@tonic-gate if (strcmp(name, NVP_NAME(nvp)) != 0) 6447c478bd9Sstevel@tonic-gate continue; 6457c478bd9Sstevel@tonic-gate 6467c478bd9Sstevel@tonic-gate nvp_buf_unlink(nvl, nvp); 6477c478bd9Sstevel@tonic-gate nvpair_free(nvp); 6487c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate error = 0; 6517c478bd9Sstevel@tonic-gate } 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate return (error); 6547c478bd9Sstevel@tonic-gate } 6557c478bd9Sstevel@tonic-gate 6567c478bd9Sstevel@tonic-gate /* 6577c478bd9Sstevel@tonic-gate * Remove first one with matching name and type 6587c478bd9Sstevel@tonic-gate */ 6597c478bd9Sstevel@tonic-gate int 6607c478bd9Sstevel@tonic-gate nvlist_remove(nvlist_t *nvl, const char *name, data_type_t type) 6617c478bd9Sstevel@tonic-gate { 6627c478bd9Sstevel@tonic-gate nvpriv_t *priv; 6637c478bd9Sstevel@tonic-gate i_nvp_t *curr; 6647c478bd9Sstevel@tonic-gate 6657c478bd9Sstevel@tonic-gate if (nvl == NULL || name == NULL || 6667c478bd9Sstevel@tonic-gate (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 6677c478bd9Sstevel@tonic-gate return (EINVAL); 6687c478bd9Sstevel@tonic-gate 6697c478bd9Sstevel@tonic-gate curr = priv->nvp_list; 6707c478bd9Sstevel@tonic-gate while (curr != NULL) { 6717c478bd9Sstevel@tonic-gate nvpair_t *nvp = &curr->nvi_nvp; 6727c478bd9Sstevel@tonic-gate 6737c478bd9Sstevel@tonic-gate if (strcmp(name, NVP_NAME(nvp)) == 0 && NVP_TYPE(nvp) == type) { 6747c478bd9Sstevel@tonic-gate nvp_buf_unlink(nvl, nvp); 6757c478bd9Sstevel@tonic-gate nvpair_free(nvp); 6767c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate return (0); 6797c478bd9Sstevel@tonic-gate } 6807c478bd9Sstevel@tonic-gate curr = curr->nvi_next; 6817c478bd9Sstevel@tonic-gate } 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate return (ENOENT); 6847c478bd9Sstevel@tonic-gate } 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate /* 6877c478bd9Sstevel@tonic-gate * This function calculates the size of an nvpair value. 6887c478bd9Sstevel@tonic-gate * 6897c478bd9Sstevel@tonic-gate * The data argument controls the behavior in case of the data types 6907c478bd9Sstevel@tonic-gate * DATA_TYPE_STRING and 6917c478bd9Sstevel@tonic-gate * DATA_TYPE_STRING_ARRAY 6927c478bd9Sstevel@tonic-gate * Is data == NULL then the size of the string(s) is excluded. 6937c478bd9Sstevel@tonic-gate */ 6947c478bd9Sstevel@tonic-gate static int 6957c478bd9Sstevel@tonic-gate i_get_value_size(data_type_t type, const void *data, uint_t nelem) 6967c478bd9Sstevel@tonic-gate { 6977c478bd9Sstevel@tonic-gate uint64_t value_sz; 6987c478bd9Sstevel@tonic-gate 6997c478bd9Sstevel@tonic-gate if (i_validate_type_nelem(type, nelem) != 0) 7007c478bd9Sstevel@tonic-gate return (-1); 7017c478bd9Sstevel@tonic-gate 7027c478bd9Sstevel@tonic-gate /* Calculate required size for holding value */ 7037c478bd9Sstevel@tonic-gate switch (type) { 7047c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 7057c478bd9Sstevel@tonic-gate value_sz = 0; 7067c478bd9Sstevel@tonic-gate break; 7077c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 7087c478bd9Sstevel@tonic-gate value_sz = sizeof (boolean_t); 7097c478bd9Sstevel@tonic-gate break; 7107c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE: 7117c478bd9Sstevel@tonic-gate value_sz = sizeof (uchar_t); 7127c478bd9Sstevel@tonic-gate break; 7137c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8: 7147c478bd9Sstevel@tonic-gate value_sz = sizeof (int8_t); 7157c478bd9Sstevel@tonic-gate break; 7167c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8: 7177c478bd9Sstevel@tonic-gate value_sz = sizeof (uint8_t); 7187c478bd9Sstevel@tonic-gate break; 7197c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16: 7207c478bd9Sstevel@tonic-gate value_sz = sizeof (int16_t); 7217c478bd9Sstevel@tonic-gate break; 7227c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16: 7237c478bd9Sstevel@tonic-gate value_sz = sizeof (uint16_t); 7247c478bd9Sstevel@tonic-gate break; 7257c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32: 7267c478bd9Sstevel@tonic-gate value_sz = sizeof (int32_t); 7277c478bd9Sstevel@tonic-gate break; 7287c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32: 7297c478bd9Sstevel@tonic-gate value_sz = sizeof (uint32_t); 7307c478bd9Sstevel@tonic-gate break; 7317c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64: 7327c478bd9Sstevel@tonic-gate value_sz = sizeof (int64_t); 7337c478bd9Sstevel@tonic-gate break; 7347c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64: 7357c478bd9Sstevel@tonic-gate value_sz = sizeof (uint64_t); 7367c478bd9Sstevel@tonic-gate break; 7377c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING: 7387c478bd9Sstevel@tonic-gate if (data == NULL) 7397c478bd9Sstevel@tonic-gate value_sz = 0; 7407c478bd9Sstevel@tonic-gate else 7417c478bd9Sstevel@tonic-gate value_sz = strlen(data) + 1; 7427c478bd9Sstevel@tonic-gate break; 7437c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: 7447c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (boolean_t); 7457c478bd9Sstevel@tonic-gate break; 7467c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE_ARRAY: 7477c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uchar_t); 7487c478bd9Sstevel@tonic-gate break; 7497c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8_ARRAY: 7507c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (int8_t); 7517c478bd9Sstevel@tonic-gate break; 7527c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8_ARRAY: 7537c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uint8_t); 7547c478bd9Sstevel@tonic-gate break; 7557c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16_ARRAY: 7567c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (int16_t); 7577c478bd9Sstevel@tonic-gate break; 7587c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16_ARRAY: 7597c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uint16_t); 7607c478bd9Sstevel@tonic-gate break; 7617c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32_ARRAY: 7627c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (int32_t); 7637c478bd9Sstevel@tonic-gate break; 7647c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32_ARRAY: 7657c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uint32_t); 7667c478bd9Sstevel@tonic-gate break; 7677c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64_ARRAY: 7687c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (int64_t); 7697c478bd9Sstevel@tonic-gate break; 7707c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64_ARRAY: 7717c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uint64_t); 7727c478bd9Sstevel@tonic-gate break; 7737c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: 7747c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uint64_t); 7757c478bd9Sstevel@tonic-gate 7767c478bd9Sstevel@tonic-gate if (data != NULL) { 7777c478bd9Sstevel@tonic-gate char *const *strs = data; 7787c478bd9Sstevel@tonic-gate uint_t i; 7797c478bd9Sstevel@tonic-gate 7807c478bd9Sstevel@tonic-gate /* no alignment requirement for strings */ 7817c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 7827c478bd9Sstevel@tonic-gate if (strs[i] == NULL) 7837c478bd9Sstevel@tonic-gate return (-1); 7847c478bd9Sstevel@tonic-gate value_sz += strlen(strs[i]) + 1; 7857c478bd9Sstevel@tonic-gate } 7867c478bd9Sstevel@tonic-gate } 7877c478bd9Sstevel@tonic-gate break; 7887c478bd9Sstevel@tonic-gate case DATA_TYPE_HRTIME: 7897c478bd9Sstevel@tonic-gate value_sz = sizeof (hrtime_t); 7907c478bd9Sstevel@tonic-gate break; 7917c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 7927c478bd9Sstevel@tonic-gate value_sz = NV_ALIGN(sizeof (nvlist_t)); 7937c478bd9Sstevel@tonic-gate break; 7947c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: 7957c478bd9Sstevel@tonic-gate value_sz = (uint64_t)nelem * sizeof (uint64_t) + 7967c478bd9Sstevel@tonic-gate (uint64_t)nelem * NV_ALIGN(sizeof (nvlist_t)); 7977c478bd9Sstevel@tonic-gate break; 7987c478bd9Sstevel@tonic-gate default: 7997c478bd9Sstevel@tonic-gate return (-1); 8007c478bd9Sstevel@tonic-gate } 8017c478bd9Sstevel@tonic-gate 8027c478bd9Sstevel@tonic-gate return (value_sz > INT32_MAX ? -1 : (int)value_sz); 8037c478bd9Sstevel@tonic-gate } 8047c478bd9Sstevel@tonic-gate 8057c478bd9Sstevel@tonic-gate static int 8067c478bd9Sstevel@tonic-gate nvlist_copy_embedded(nvlist_t *nvl, nvlist_t *onvl, nvlist_t *emb_nvl) 8077c478bd9Sstevel@tonic-gate { 8087c478bd9Sstevel@tonic-gate nvpriv_t *priv; 8097c478bd9Sstevel@tonic-gate int err; 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate if ((priv = nv_priv_alloc_embedded((nvpriv_t *)(uintptr_t) 8127c478bd9Sstevel@tonic-gate nvl->nvl_priv)) == NULL) 8137c478bd9Sstevel@tonic-gate return (ENOMEM); 8147c478bd9Sstevel@tonic-gate 8157c478bd9Sstevel@tonic-gate nvlist_init(emb_nvl, onvl->nvl_nvflag, priv); 8167c478bd9Sstevel@tonic-gate 8177c478bd9Sstevel@tonic-gate if ((err = nvlist_copy_pairs(onvl, emb_nvl)) != 0) { 8187c478bd9Sstevel@tonic-gate nvlist_free(emb_nvl); 8197c478bd9Sstevel@tonic-gate emb_nvl->nvl_priv = 0; 8207c478bd9Sstevel@tonic-gate } 8217c478bd9Sstevel@tonic-gate 8227c478bd9Sstevel@tonic-gate return (err); 8237c478bd9Sstevel@tonic-gate } 8247c478bd9Sstevel@tonic-gate 8257c478bd9Sstevel@tonic-gate /* 8267c478bd9Sstevel@tonic-gate * nvlist_add_common - Add new <name,value> pair to nvlist 8277c478bd9Sstevel@tonic-gate */ 8287c478bd9Sstevel@tonic-gate static int 8297c478bd9Sstevel@tonic-gate nvlist_add_common(nvlist_t *nvl, const char *name, 8307c478bd9Sstevel@tonic-gate data_type_t type, uint_t nelem, const void *data) 8317c478bd9Sstevel@tonic-gate { 8327c478bd9Sstevel@tonic-gate nvpair_t *nvp; 833*d9638e54Smws uint_t i; 834*d9638e54Smws 8357c478bd9Sstevel@tonic-gate int nvp_sz, name_sz, value_sz; 8367c478bd9Sstevel@tonic-gate int err = 0; 8377c478bd9Sstevel@tonic-gate 8387c478bd9Sstevel@tonic-gate if (name == NULL || nvl == NULL || nvl->nvl_priv == 0) 8397c478bd9Sstevel@tonic-gate return (EINVAL); 8407c478bd9Sstevel@tonic-gate 8417c478bd9Sstevel@tonic-gate if (nelem != 0 && data == NULL) 8427c478bd9Sstevel@tonic-gate return (EINVAL); 8437c478bd9Sstevel@tonic-gate 8447c478bd9Sstevel@tonic-gate /* 8457c478bd9Sstevel@tonic-gate * Verify type and nelem and get the value size. 8467c478bd9Sstevel@tonic-gate * In case of data types DATA_TYPE_STRING and DATA_TYPE_STRING_ARRAY 8477c478bd9Sstevel@tonic-gate * is the size of the string(s) included. 8487c478bd9Sstevel@tonic-gate */ 8497c478bd9Sstevel@tonic-gate if ((value_sz = i_get_value_size(type, data, nelem)) < 0) 8507c478bd9Sstevel@tonic-gate return (EINVAL); 8517c478bd9Sstevel@tonic-gate 8527c478bd9Sstevel@tonic-gate if (i_validate_nvpair_value(type, nelem, data) != 0) 8537c478bd9Sstevel@tonic-gate return (EINVAL); 8547c478bd9Sstevel@tonic-gate 855*d9638e54Smws /* 856*d9638e54Smws * If we're adding an nvlist or nvlist array, ensure that we are not 857*d9638e54Smws * adding the input nvlist to itself, which would cause recursion, 858*d9638e54Smws * and ensure that no NULL nvlist pointers are present. 859*d9638e54Smws */ 8607c478bd9Sstevel@tonic-gate switch (type) { 8617c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 862*d9638e54Smws if (data == nvl || data == NULL) 8637c478bd9Sstevel@tonic-gate return (EINVAL); 8647c478bd9Sstevel@tonic-gate break; 8657c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: { 866*d9638e54Smws nvlist_t **onvlp = (nvlist_t **)data; 867*d9638e54Smws for (i = 0; i < nelem; i++) { 868*d9638e54Smws if (onvlp[i] == nvl || onvlp[i] == NULL) 8697c478bd9Sstevel@tonic-gate return (EINVAL); 8707c478bd9Sstevel@tonic-gate } 8717c478bd9Sstevel@tonic-gate break; 872*d9638e54Smws } 8737c478bd9Sstevel@tonic-gate } 8747c478bd9Sstevel@tonic-gate 8757c478bd9Sstevel@tonic-gate /* calculate sizes of the nvpair elements and the nvpair itself */ 8767c478bd9Sstevel@tonic-gate name_sz = strlen(name) + 1; 8777c478bd9Sstevel@tonic-gate 8787c478bd9Sstevel@tonic-gate nvp_sz = NVP_SIZE_CALC(name_sz, value_sz); 8797c478bd9Sstevel@tonic-gate 8807c478bd9Sstevel@tonic-gate if ((nvp = nvp_buf_alloc(nvl, nvp_sz)) == NULL) 8817c478bd9Sstevel@tonic-gate return (ENOMEM); 8827c478bd9Sstevel@tonic-gate 8837c478bd9Sstevel@tonic-gate ASSERT(nvp->nvp_size == nvp_sz); 8847c478bd9Sstevel@tonic-gate nvp->nvp_name_sz = name_sz; 8857c478bd9Sstevel@tonic-gate nvp->nvp_value_elem = nelem; 8867c478bd9Sstevel@tonic-gate nvp->nvp_type = type; 8877c478bd9Sstevel@tonic-gate bcopy(name, NVP_NAME(nvp), name_sz); 8887c478bd9Sstevel@tonic-gate 8897c478bd9Sstevel@tonic-gate switch (type) { 8907c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 8917c478bd9Sstevel@tonic-gate break; 8927c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: { 8937c478bd9Sstevel@tonic-gate char *const *strs = data; 8947c478bd9Sstevel@tonic-gate char *buf = NVP_VALUE(nvp); 8957c478bd9Sstevel@tonic-gate char **cstrs = (void *)buf; 8967c478bd9Sstevel@tonic-gate 8977c478bd9Sstevel@tonic-gate /* skip pre-allocated space for pointer array */ 8987c478bd9Sstevel@tonic-gate buf += nelem * sizeof (uint64_t); 8997c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 9007c478bd9Sstevel@tonic-gate int slen = strlen(strs[i]) + 1; 9017c478bd9Sstevel@tonic-gate bcopy(strs[i], buf, slen); 9027c478bd9Sstevel@tonic-gate cstrs[i] = buf; 9037c478bd9Sstevel@tonic-gate buf += slen; 9047c478bd9Sstevel@tonic-gate } 9057c478bd9Sstevel@tonic-gate break; 9067c478bd9Sstevel@tonic-gate } 9077c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: { 9087c478bd9Sstevel@tonic-gate nvlist_t *nnvl = EMBEDDED_NVL(nvp); 9097c478bd9Sstevel@tonic-gate nvlist_t *onvl = (nvlist_t *)data; 9107c478bd9Sstevel@tonic-gate 9117c478bd9Sstevel@tonic-gate if ((err = nvlist_copy_embedded(nvl, onvl, nnvl)) != 0) { 9127c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 9137c478bd9Sstevel@tonic-gate return (err); 9147c478bd9Sstevel@tonic-gate } 9157c478bd9Sstevel@tonic-gate break; 9167c478bd9Sstevel@tonic-gate } 9177c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: { 9187c478bd9Sstevel@tonic-gate nvlist_t **onvlp = (nvlist_t **)data; 9197c478bd9Sstevel@tonic-gate nvlist_t **nvlp = EMBEDDED_NVL_ARRAY(nvp); 9207c478bd9Sstevel@tonic-gate nvlist_t *embedded = (nvlist_t *) 9217c478bd9Sstevel@tonic-gate ((uintptr_t)nvlp + nelem * sizeof (uint64_t)); 9227c478bd9Sstevel@tonic-gate 9237c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 9247c478bd9Sstevel@tonic-gate if ((err = nvlist_copy_embedded(nvl, 9257c478bd9Sstevel@tonic-gate onvlp[i], embedded)) != 0) { 9267c478bd9Sstevel@tonic-gate /* 9277c478bd9Sstevel@tonic-gate * Free any successfully created lists 9287c478bd9Sstevel@tonic-gate */ 9297c478bd9Sstevel@tonic-gate nvpair_free(nvp); 9307c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 9317c478bd9Sstevel@tonic-gate return (err); 9327c478bd9Sstevel@tonic-gate } 9337c478bd9Sstevel@tonic-gate 9347c478bd9Sstevel@tonic-gate nvlp[i] = embedded++; 9357c478bd9Sstevel@tonic-gate } 9367c478bd9Sstevel@tonic-gate break; 9377c478bd9Sstevel@tonic-gate } 9387c478bd9Sstevel@tonic-gate default: 9397c478bd9Sstevel@tonic-gate bcopy(data, NVP_VALUE(nvp), value_sz); 9407c478bd9Sstevel@tonic-gate } 9417c478bd9Sstevel@tonic-gate 9427c478bd9Sstevel@tonic-gate /* if unique name, remove before add */ 9437c478bd9Sstevel@tonic-gate if (nvl->nvl_nvflag & NV_UNIQUE_NAME) 9447c478bd9Sstevel@tonic-gate (void) nvlist_remove_all(nvl, name); 9457c478bd9Sstevel@tonic-gate else if (nvl->nvl_nvflag & NV_UNIQUE_NAME_TYPE) 9467c478bd9Sstevel@tonic-gate (void) nvlist_remove(nvl, name, type); 9477c478bd9Sstevel@tonic-gate 9487c478bd9Sstevel@tonic-gate nvp_buf_link(nvl, nvp); 9497c478bd9Sstevel@tonic-gate 9507c478bd9Sstevel@tonic-gate return (0); 9517c478bd9Sstevel@tonic-gate } 9527c478bd9Sstevel@tonic-gate 9537c478bd9Sstevel@tonic-gate int 9547c478bd9Sstevel@tonic-gate nvlist_add_boolean(nvlist_t *nvl, const char *name) 9557c478bd9Sstevel@tonic-gate { 9567c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN, 0, NULL)); 9577c478bd9Sstevel@tonic-gate } 9587c478bd9Sstevel@tonic-gate 9597c478bd9Sstevel@tonic-gate int 9607c478bd9Sstevel@tonic-gate nvlist_add_boolean_value(nvlist_t *nvl, const char *name, boolean_t val) 9617c478bd9Sstevel@tonic-gate { 9627c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN_VALUE, 1, &val)); 9637c478bd9Sstevel@tonic-gate } 9647c478bd9Sstevel@tonic-gate 9657c478bd9Sstevel@tonic-gate int 9667c478bd9Sstevel@tonic-gate nvlist_add_byte(nvlist_t *nvl, const char *name, uchar_t val) 9677c478bd9Sstevel@tonic-gate { 9687c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_BYTE, 1, &val)); 9697c478bd9Sstevel@tonic-gate } 9707c478bd9Sstevel@tonic-gate 9717c478bd9Sstevel@tonic-gate int 9727c478bd9Sstevel@tonic-gate nvlist_add_int8(nvlist_t *nvl, const char *name, int8_t val) 9737c478bd9Sstevel@tonic-gate { 9747c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT8, 1, &val)); 9757c478bd9Sstevel@tonic-gate } 9767c478bd9Sstevel@tonic-gate 9777c478bd9Sstevel@tonic-gate int 9787c478bd9Sstevel@tonic-gate nvlist_add_uint8(nvlist_t *nvl, const char *name, uint8_t val) 9797c478bd9Sstevel@tonic-gate { 9807c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT8, 1, &val)); 9817c478bd9Sstevel@tonic-gate } 9827c478bd9Sstevel@tonic-gate 9837c478bd9Sstevel@tonic-gate int 9847c478bd9Sstevel@tonic-gate nvlist_add_int16(nvlist_t *nvl, const char *name, int16_t val) 9857c478bd9Sstevel@tonic-gate { 9867c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT16, 1, &val)); 9877c478bd9Sstevel@tonic-gate } 9887c478bd9Sstevel@tonic-gate 9897c478bd9Sstevel@tonic-gate int 9907c478bd9Sstevel@tonic-gate nvlist_add_uint16(nvlist_t *nvl, const char *name, uint16_t val) 9917c478bd9Sstevel@tonic-gate { 9927c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT16, 1, &val)); 9937c478bd9Sstevel@tonic-gate } 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate int 9967c478bd9Sstevel@tonic-gate nvlist_add_int32(nvlist_t *nvl, const char *name, int32_t val) 9977c478bd9Sstevel@tonic-gate { 9987c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT32, 1, &val)); 9997c478bd9Sstevel@tonic-gate } 10007c478bd9Sstevel@tonic-gate 10017c478bd9Sstevel@tonic-gate int 10027c478bd9Sstevel@tonic-gate nvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val) 10037c478bd9Sstevel@tonic-gate { 10047c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT32, 1, &val)); 10057c478bd9Sstevel@tonic-gate } 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate int 10087c478bd9Sstevel@tonic-gate nvlist_add_int64(nvlist_t *nvl, const char *name, int64_t val) 10097c478bd9Sstevel@tonic-gate { 10107c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT64, 1, &val)); 10117c478bd9Sstevel@tonic-gate } 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate int 10147c478bd9Sstevel@tonic-gate nvlist_add_uint64(nvlist_t *nvl, const char *name, uint64_t val) 10157c478bd9Sstevel@tonic-gate { 10167c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT64, 1, &val)); 10177c478bd9Sstevel@tonic-gate } 10187c478bd9Sstevel@tonic-gate 10197c478bd9Sstevel@tonic-gate int 10207c478bd9Sstevel@tonic-gate nvlist_add_string(nvlist_t *nvl, const char *name, const char *val) 10217c478bd9Sstevel@tonic-gate { 10227c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_STRING, 1, (void *)val)); 10237c478bd9Sstevel@tonic-gate } 10247c478bd9Sstevel@tonic-gate 10257c478bd9Sstevel@tonic-gate int 10267c478bd9Sstevel@tonic-gate nvlist_add_boolean_array(nvlist_t *nvl, const char *name, 10277c478bd9Sstevel@tonic-gate boolean_t *a, uint_t n) 10287c478bd9Sstevel@tonic-gate { 10297c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN_ARRAY, n, a)); 10307c478bd9Sstevel@tonic-gate } 10317c478bd9Sstevel@tonic-gate 10327c478bd9Sstevel@tonic-gate int 10337c478bd9Sstevel@tonic-gate nvlist_add_byte_array(nvlist_t *nvl, const char *name, uchar_t *a, uint_t n) 10347c478bd9Sstevel@tonic-gate { 10357c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_BYTE_ARRAY, n, a)); 10367c478bd9Sstevel@tonic-gate } 10377c478bd9Sstevel@tonic-gate 10387c478bd9Sstevel@tonic-gate int 10397c478bd9Sstevel@tonic-gate nvlist_add_int8_array(nvlist_t *nvl, const char *name, int8_t *a, uint_t n) 10407c478bd9Sstevel@tonic-gate { 10417c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT8_ARRAY, n, a)); 10427c478bd9Sstevel@tonic-gate } 10437c478bd9Sstevel@tonic-gate 10447c478bd9Sstevel@tonic-gate int 10457c478bd9Sstevel@tonic-gate nvlist_add_uint8_array(nvlist_t *nvl, const char *name, uint8_t *a, uint_t n) 10467c478bd9Sstevel@tonic-gate { 10477c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT8_ARRAY, n, a)); 10487c478bd9Sstevel@tonic-gate } 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate int 10517c478bd9Sstevel@tonic-gate nvlist_add_int16_array(nvlist_t *nvl, const char *name, int16_t *a, uint_t n) 10527c478bd9Sstevel@tonic-gate { 10537c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT16_ARRAY, n, a)); 10547c478bd9Sstevel@tonic-gate } 10557c478bd9Sstevel@tonic-gate 10567c478bd9Sstevel@tonic-gate int 10577c478bd9Sstevel@tonic-gate nvlist_add_uint16_array(nvlist_t *nvl, const char *name, uint16_t *a, uint_t n) 10587c478bd9Sstevel@tonic-gate { 10597c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT16_ARRAY, n, a)); 10607c478bd9Sstevel@tonic-gate } 10617c478bd9Sstevel@tonic-gate 10627c478bd9Sstevel@tonic-gate int 10637c478bd9Sstevel@tonic-gate nvlist_add_int32_array(nvlist_t *nvl, const char *name, int32_t *a, uint_t n) 10647c478bd9Sstevel@tonic-gate { 10657c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT32_ARRAY, n, a)); 10667c478bd9Sstevel@tonic-gate } 10677c478bd9Sstevel@tonic-gate 10687c478bd9Sstevel@tonic-gate int 10697c478bd9Sstevel@tonic-gate nvlist_add_uint32_array(nvlist_t *nvl, const char *name, uint32_t *a, uint_t n) 10707c478bd9Sstevel@tonic-gate { 10717c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT32_ARRAY, n, a)); 10727c478bd9Sstevel@tonic-gate } 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate int 10757c478bd9Sstevel@tonic-gate nvlist_add_int64_array(nvlist_t *nvl, const char *name, int64_t *a, uint_t n) 10767c478bd9Sstevel@tonic-gate { 10777c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_INT64_ARRAY, n, a)); 10787c478bd9Sstevel@tonic-gate } 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate int 10817c478bd9Sstevel@tonic-gate nvlist_add_uint64_array(nvlist_t *nvl, const char *name, uint64_t *a, uint_t n) 10827c478bd9Sstevel@tonic-gate { 10837c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_UINT64_ARRAY, n, a)); 10847c478bd9Sstevel@tonic-gate } 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate int 10877c478bd9Sstevel@tonic-gate nvlist_add_string_array(nvlist_t *nvl, const char *name, 10887c478bd9Sstevel@tonic-gate char *const *a, uint_t n) 10897c478bd9Sstevel@tonic-gate { 10907c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_STRING_ARRAY, n, a)); 10917c478bd9Sstevel@tonic-gate } 10927c478bd9Sstevel@tonic-gate 10937c478bd9Sstevel@tonic-gate int 10947c478bd9Sstevel@tonic-gate nvlist_add_hrtime(nvlist_t *nvl, const char *name, hrtime_t val) 10957c478bd9Sstevel@tonic-gate { 10967c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_HRTIME, 1, &val)); 10977c478bd9Sstevel@tonic-gate } 10987c478bd9Sstevel@tonic-gate 10997c478bd9Sstevel@tonic-gate int 11007c478bd9Sstevel@tonic-gate nvlist_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val) 11017c478bd9Sstevel@tonic-gate { 11027c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_NVLIST, 1, val)); 11037c478bd9Sstevel@tonic-gate } 11047c478bd9Sstevel@tonic-gate 11057c478bd9Sstevel@tonic-gate int 11067c478bd9Sstevel@tonic-gate nvlist_add_nvlist_array(nvlist_t *nvl, const char *name, nvlist_t **a, uint_t n) 11077c478bd9Sstevel@tonic-gate { 11087c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, name, DATA_TYPE_NVLIST_ARRAY, n, a)); 11097c478bd9Sstevel@tonic-gate } 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate /* reading name-value pairs */ 11127c478bd9Sstevel@tonic-gate nvpair_t * 11137c478bd9Sstevel@tonic-gate nvlist_next_nvpair(nvlist_t *nvl, nvpair_t *nvp) 11147c478bd9Sstevel@tonic-gate { 11157c478bd9Sstevel@tonic-gate nvpriv_t *priv; 11167c478bd9Sstevel@tonic-gate i_nvp_t *curr; 11177c478bd9Sstevel@tonic-gate 11187c478bd9Sstevel@tonic-gate if (nvl == NULL || 11197c478bd9Sstevel@tonic-gate (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 11207c478bd9Sstevel@tonic-gate return (NULL); 11217c478bd9Sstevel@tonic-gate 11227c478bd9Sstevel@tonic-gate curr = NVPAIR2I_NVP(nvp); 11237c478bd9Sstevel@tonic-gate 11247c478bd9Sstevel@tonic-gate /* 11257c478bd9Sstevel@tonic-gate * Ensure that nvp is an valid pointer. 11267c478bd9Sstevel@tonic-gate */ 11277c478bd9Sstevel@tonic-gate if (nvp == NULL) 11287c478bd9Sstevel@tonic-gate curr = priv->nvp_list; 11297c478bd9Sstevel@tonic-gate else if (priv->nvp_curr == curr) 11307c478bd9Sstevel@tonic-gate curr = curr->nvi_next; 11317c478bd9Sstevel@tonic-gate else if (nvlist_contains_nvp(nvl, nvp) == 0) 11327c478bd9Sstevel@tonic-gate curr = NULL; 11337c478bd9Sstevel@tonic-gate 11347c478bd9Sstevel@tonic-gate priv->nvp_curr = curr; 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate return (curr != NULL ? &curr->nvi_nvp : NULL); 11377c478bd9Sstevel@tonic-gate } 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate char * 11407c478bd9Sstevel@tonic-gate nvpair_name(nvpair_t *nvp) 11417c478bd9Sstevel@tonic-gate { 11427c478bd9Sstevel@tonic-gate return (NVP_NAME(nvp)); 11437c478bd9Sstevel@tonic-gate } 11447c478bd9Sstevel@tonic-gate 11457c478bd9Sstevel@tonic-gate data_type_t 11467c478bd9Sstevel@tonic-gate nvpair_type(nvpair_t *nvp) 11477c478bd9Sstevel@tonic-gate { 11487c478bd9Sstevel@tonic-gate return (NVP_TYPE(nvp)); 11497c478bd9Sstevel@tonic-gate } 11507c478bd9Sstevel@tonic-gate 11517c478bd9Sstevel@tonic-gate static int 11527c478bd9Sstevel@tonic-gate nvpair_value_common(nvpair_t *nvp, data_type_t type, uint_t *nelem, void *data) 11537c478bd9Sstevel@tonic-gate { 11547c478bd9Sstevel@tonic-gate if (nvp == NULL || nvpair_type(nvp) != type) 11557c478bd9Sstevel@tonic-gate return (EINVAL); 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate /* 11587c478bd9Sstevel@tonic-gate * For non-array types, we copy the data. 11597c478bd9Sstevel@tonic-gate * For array types (including string), we set a pointer. 11607c478bd9Sstevel@tonic-gate */ 11617c478bd9Sstevel@tonic-gate switch (type) { 11627c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 11637c478bd9Sstevel@tonic-gate if (nelem != NULL) 11647c478bd9Sstevel@tonic-gate *nelem = 0; 11657c478bd9Sstevel@tonic-gate break; 11667c478bd9Sstevel@tonic-gate 11677c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 11687c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE: 11697c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8: 11707c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8: 11717c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16: 11727c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16: 11737c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32: 11747c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32: 11757c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64: 11767c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64: 11777c478bd9Sstevel@tonic-gate case DATA_TYPE_HRTIME: 11787c478bd9Sstevel@tonic-gate if (data == NULL) 11797c478bd9Sstevel@tonic-gate return (EINVAL); 11807c478bd9Sstevel@tonic-gate bcopy(NVP_VALUE(nvp), data, 11817c478bd9Sstevel@tonic-gate (size_t)i_get_value_size(type, NULL, 1)); 11827c478bd9Sstevel@tonic-gate if (nelem != NULL) 11837c478bd9Sstevel@tonic-gate *nelem = 1; 11847c478bd9Sstevel@tonic-gate break; 11857c478bd9Sstevel@tonic-gate 11867c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 11877c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING: 11887c478bd9Sstevel@tonic-gate if (data == NULL) 11897c478bd9Sstevel@tonic-gate return (EINVAL); 11907c478bd9Sstevel@tonic-gate *(void **)data = (void *)NVP_VALUE(nvp); 11917c478bd9Sstevel@tonic-gate if (nelem != NULL) 11927c478bd9Sstevel@tonic-gate *nelem = 1; 11937c478bd9Sstevel@tonic-gate break; 11947c478bd9Sstevel@tonic-gate 11957c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: 11967c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE_ARRAY: 11977c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8_ARRAY: 11987c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8_ARRAY: 11997c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16_ARRAY: 12007c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16_ARRAY: 12017c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32_ARRAY: 12027c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32_ARRAY: 12037c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64_ARRAY: 12047c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64_ARRAY: 12057c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: 12067c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: 12077c478bd9Sstevel@tonic-gate if (nelem == NULL || data == NULL) 12087c478bd9Sstevel@tonic-gate return (EINVAL); 12097c478bd9Sstevel@tonic-gate if ((*nelem = NVP_NELEM(nvp)) != 0) 12107c478bd9Sstevel@tonic-gate *(void **)data = (void *)NVP_VALUE(nvp); 12117c478bd9Sstevel@tonic-gate else 12127c478bd9Sstevel@tonic-gate *(void **)data = NULL; 12137c478bd9Sstevel@tonic-gate break; 12147c478bd9Sstevel@tonic-gate 12157c478bd9Sstevel@tonic-gate default: 12167c478bd9Sstevel@tonic-gate return (ENOTSUP); 12177c478bd9Sstevel@tonic-gate } 12187c478bd9Sstevel@tonic-gate 12197c478bd9Sstevel@tonic-gate return (0); 12207c478bd9Sstevel@tonic-gate } 12217c478bd9Sstevel@tonic-gate 12227c478bd9Sstevel@tonic-gate static int 12237c478bd9Sstevel@tonic-gate nvlist_lookup_common(nvlist_t *nvl, const char *name, data_type_t type, 12247c478bd9Sstevel@tonic-gate uint_t *nelem, void *data) 12257c478bd9Sstevel@tonic-gate { 12267c478bd9Sstevel@tonic-gate nvpriv_t *priv; 12277c478bd9Sstevel@tonic-gate nvpair_t *nvp; 12287c478bd9Sstevel@tonic-gate i_nvp_t *curr; 12297c478bd9Sstevel@tonic-gate 12307c478bd9Sstevel@tonic-gate if (name == NULL || nvl == NULL || 12317c478bd9Sstevel@tonic-gate (priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 12327c478bd9Sstevel@tonic-gate return (EINVAL); 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate if (!(nvl->nvl_nvflag & (NV_UNIQUE_NAME | NV_UNIQUE_NAME_TYPE))) 12357c478bd9Sstevel@tonic-gate return (ENOTSUP); 12367c478bd9Sstevel@tonic-gate 12377c478bd9Sstevel@tonic-gate for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) { 12387c478bd9Sstevel@tonic-gate nvp = &curr->nvi_nvp; 12397c478bd9Sstevel@tonic-gate 12407c478bd9Sstevel@tonic-gate if (strcmp(name, NVP_NAME(nvp)) == 0 && NVP_TYPE(nvp) == type) 12417c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, type, nelem, data)); 12427c478bd9Sstevel@tonic-gate } 12437c478bd9Sstevel@tonic-gate 12447c478bd9Sstevel@tonic-gate return (ENOENT); 12457c478bd9Sstevel@tonic-gate } 12467c478bd9Sstevel@tonic-gate 12477c478bd9Sstevel@tonic-gate int 12487c478bd9Sstevel@tonic-gate nvlist_lookup_boolean(nvlist_t *nvl, const char *name) 12497c478bd9Sstevel@tonic-gate { 12507c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_BOOLEAN, NULL, NULL)); 12517c478bd9Sstevel@tonic-gate } 12527c478bd9Sstevel@tonic-gate 12537c478bd9Sstevel@tonic-gate int 12547c478bd9Sstevel@tonic-gate nvlist_lookup_boolean_value(nvlist_t *nvl, const char *name, boolean_t *val) 12557c478bd9Sstevel@tonic-gate { 12567c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, 12577c478bd9Sstevel@tonic-gate DATA_TYPE_BOOLEAN_VALUE, NULL, val)); 12587c478bd9Sstevel@tonic-gate } 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate int 12617c478bd9Sstevel@tonic-gate nvlist_lookup_byte(nvlist_t *nvl, const char *name, uchar_t *val) 12627c478bd9Sstevel@tonic-gate { 12637c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_BYTE, NULL, val)); 12647c478bd9Sstevel@tonic-gate } 12657c478bd9Sstevel@tonic-gate 12667c478bd9Sstevel@tonic-gate int 12677c478bd9Sstevel@tonic-gate nvlist_lookup_int8(nvlist_t *nvl, const char *name, int8_t *val) 12687c478bd9Sstevel@tonic-gate { 12697c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT8, NULL, val)); 12707c478bd9Sstevel@tonic-gate } 12717c478bd9Sstevel@tonic-gate 12727c478bd9Sstevel@tonic-gate int 12737c478bd9Sstevel@tonic-gate nvlist_lookup_uint8(nvlist_t *nvl, const char *name, uint8_t *val) 12747c478bd9Sstevel@tonic-gate { 12757c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT8, NULL, val)); 12767c478bd9Sstevel@tonic-gate } 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate int 12797c478bd9Sstevel@tonic-gate nvlist_lookup_int16(nvlist_t *nvl, const char *name, int16_t *val) 12807c478bd9Sstevel@tonic-gate { 12817c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT16, NULL, val)); 12827c478bd9Sstevel@tonic-gate } 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate int 12857c478bd9Sstevel@tonic-gate nvlist_lookup_uint16(nvlist_t *nvl, const char *name, uint16_t *val) 12867c478bd9Sstevel@tonic-gate { 12877c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT16, NULL, val)); 12887c478bd9Sstevel@tonic-gate } 12897c478bd9Sstevel@tonic-gate 12907c478bd9Sstevel@tonic-gate int 12917c478bd9Sstevel@tonic-gate nvlist_lookup_int32(nvlist_t *nvl, const char *name, int32_t *val) 12927c478bd9Sstevel@tonic-gate { 12937c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT32, NULL, val)); 12947c478bd9Sstevel@tonic-gate } 12957c478bd9Sstevel@tonic-gate 12967c478bd9Sstevel@tonic-gate int 12977c478bd9Sstevel@tonic-gate nvlist_lookup_uint32(nvlist_t *nvl, const char *name, uint32_t *val) 12987c478bd9Sstevel@tonic-gate { 12997c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT32, NULL, val)); 13007c478bd9Sstevel@tonic-gate } 13017c478bd9Sstevel@tonic-gate 13027c478bd9Sstevel@tonic-gate int 13037c478bd9Sstevel@tonic-gate nvlist_lookup_int64(nvlist_t *nvl, const char *name, int64_t *val) 13047c478bd9Sstevel@tonic-gate { 13057c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT64, NULL, val)); 13067c478bd9Sstevel@tonic-gate } 13077c478bd9Sstevel@tonic-gate 13087c478bd9Sstevel@tonic-gate int 13097c478bd9Sstevel@tonic-gate nvlist_lookup_uint64(nvlist_t *nvl, const char *name, uint64_t *val) 13107c478bd9Sstevel@tonic-gate { 13117c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT64, NULL, val)); 13127c478bd9Sstevel@tonic-gate } 13137c478bd9Sstevel@tonic-gate 13147c478bd9Sstevel@tonic-gate int 13157c478bd9Sstevel@tonic-gate nvlist_lookup_string(nvlist_t *nvl, const char *name, char **val) 13167c478bd9Sstevel@tonic-gate { 13177c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_STRING, NULL, val)); 13187c478bd9Sstevel@tonic-gate } 13197c478bd9Sstevel@tonic-gate 13207c478bd9Sstevel@tonic-gate int 13217c478bd9Sstevel@tonic-gate nvlist_lookup_nvlist(nvlist_t *nvl, const char *name, nvlist_t **val) 13227c478bd9Sstevel@tonic-gate { 13237c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_NVLIST, NULL, val)); 13247c478bd9Sstevel@tonic-gate } 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate int 13277c478bd9Sstevel@tonic-gate nvlist_lookup_boolean_array(nvlist_t *nvl, const char *name, 13287c478bd9Sstevel@tonic-gate boolean_t **a, uint_t *n) 13297c478bd9Sstevel@tonic-gate { 13307c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, 13317c478bd9Sstevel@tonic-gate DATA_TYPE_BOOLEAN_ARRAY, n, a)); 13327c478bd9Sstevel@tonic-gate } 13337c478bd9Sstevel@tonic-gate 13347c478bd9Sstevel@tonic-gate int 13357c478bd9Sstevel@tonic-gate nvlist_lookup_byte_array(nvlist_t *nvl, const char *name, 13367c478bd9Sstevel@tonic-gate uchar_t **a, uint_t *n) 13377c478bd9Sstevel@tonic-gate { 13387c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_BYTE_ARRAY, n, a)); 13397c478bd9Sstevel@tonic-gate } 13407c478bd9Sstevel@tonic-gate 13417c478bd9Sstevel@tonic-gate int 13427c478bd9Sstevel@tonic-gate nvlist_lookup_int8_array(nvlist_t *nvl, const char *name, int8_t **a, uint_t *n) 13437c478bd9Sstevel@tonic-gate { 13447c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT8_ARRAY, n, a)); 13457c478bd9Sstevel@tonic-gate } 13467c478bd9Sstevel@tonic-gate 13477c478bd9Sstevel@tonic-gate int 13487c478bd9Sstevel@tonic-gate nvlist_lookup_uint8_array(nvlist_t *nvl, const char *name, 13497c478bd9Sstevel@tonic-gate uint8_t **a, uint_t *n) 13507c478bd9Sstevel@tonic-gate { 13517c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT8_ARRAY, n, a)); 13527c478bd9Sstevel@tonic-gate } 13537c478bd9Sstevel@tonic-gate 13547c478bd9Sstevel@tonic-gate int 13557c478bd9Sstevel@tonic-gate nvlist_lookup_int16_array(nvlist_t *nvl, const char *name, 13567c478bd9Sstevel@tonic-gate int16_t **a, uint_t *n) 13577c478bd9Sstevel@tonic-gate { 13587c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT16_ARRAY, n, a)); 13597c478bd9Sstevel@tonic-gate } 13607c478bd9Sstevel@tonic-gate 13617c478bd9Sstevel@tonic-gate int 13627c478bd9Sstevel@tonic-gate nvlist_lookup_uint16_array(nvlist_t *nvl, const char *name, 13637c478bd9Sstevel@tonic-gate uint16_t **a, uint_t *n) 13647c478bd9Sstevel@tonic-gate { 13657c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT16_ARRAY, n, a)); 13667c478bd9Sstevel@tonic-gate } 13677c478bd9Sstevel@tonic-gate 13687c478bd9Sstevel@tonic-gate int 13697c478bd9Sstevel@tonic-gate nvlist_lookup_int32_array(nvlist_t *nvl, const char *name, 13707c478bd9Sstevel@tonic-gate int32_t **a, uint_t *n) 13717c478bd9Sstevel@tonic-gate { 13727c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT32_ARRAY, n, a)); 13737c478bd9Sstevel@tonic-gate } 13747c478bd9Sstevel@tonic-gate 13757c478bd9Sstevel@tonic-gate int 13767c478bd9Sstevel@tonic-gate nvlist_lookup_uint32_array(nvlist_t *nvl, const char *name, 13777c478bd9Sstevel@tonic-gate uint32_t **a, uint_t *n) 13787c478bd9Sstevel@tonic-gate { 13797c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT32_ARRAY, n, a)); 13807c478bd9Sstevel@tonic-gate } 13817c478bd9Sstevel@tonic-gate 13827c478bd9Sstevel@tonic-gate int 13837c478bd9Sstevel@tonic-gate nvlist_lookup_int64_array(nvlist_t *nvl, const char *name, 13847c478bd9Sstevel@tonic-gate int64_t **a, uint_t *n) 13857c478bd9Sstevel@tonic-gate { 13867c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_INT64_ARRAY, n, a)); 13877c478bd9Sstevel@tonic-gate } 13887c478bd9Sstevel@tonic-gate 13897c478bd9Sstevel@tonic-gate int 13907c478bd9Sstevel@tonic-gate nvlist_lookup_uint64_array(nvlist_t *nvl, const char *name, 13917c478bd9Sstevel@tonic-gate uint64_t **a, uint_t *n) 13927c478bd9Sstevel@tonic-gate { 13937c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_UINT64_ARRAY, n, a)); 13947c478bd9Sstevel@tonic-gate } 13957c478bd9Sstevel@tonic-gate 13967c478bd9Sstevel@tonic-gate int 13977c478bd9Sstevel@tonic-gate nvlist_lookup_string_array(nvlist_t *nvl, const char *name, 13987c478bd9Sstevel@tonic-gate char ***a, uint_t *n) 13997c478bd9Sstevel@tonic-gate { 14007c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_STRING_ARRAY, n, a)); 14017c478bd9Sstevel@tonic-gate } 14027c478bd9Sstevel@tonic-gate 14037c478bd9Sstevel@tonic-gate int 14047c478bd9Sstevel@tonic-gate nvlist_lookup_nvlist_array(nvlist_t *nvl, const char *name, 14057c478bd9Sstevel@tonic-gate nvlist_t ***a, uint_t *n) 14067c478bd9Sstevel@tonic-gate { 14077c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_NVLIST_ARRAY, n, a)); 14087c478bd9Sstevel@tonic-gate } 14097c478bd9Sstevel@tonic-gate 14107c478bd9Sstevel@tonic-gate int 14117c478bd9Sstevel@tonic-gate nvlist_lookup_hrtime(nvlist_t *nvl, const char *name, hrtime_t *val) 14127c478bd9Sstevel@tonic-gate { 14137c478bd9Sstevel@tonic-gate return (nvlist_lookup_common(nvl, name, DATA_TYPE_HRTIME, NULL, val)); 14147c478bd9Sstevel@tonic-gate } 14157c478bd9Sstevel@tonic-gate 14167c478bd9Sstevel@tonic-gate int 14177c478bd9Sstevel@tonic-gate nvlist_lookup_pairs(nvlist_t *nvl, int flag, ...) 14187c478bd9Sstevel@tonic-gate { 14197c478bd9Sstevel@tonic-gate va_list ap; 14207c478bd9Sstevel@tonic-gate char *name; 14217c478bd9Sstevel@tonic-gate int noentok = (flag & NV_FLAG_NOENTOK ? 1 : 0); 14227c478bd9Sstevel@tonic-gate int ret = 0; 14237c478bd9Sstevel@tonic-gate 14247c478bd9Sstevel@tonic-gate va_start(ap, flag); 14257c478bd9Sstevel@tonic-gate while (ret == 0 && (name = va_arg(ap, char *)) != NULL) { 14267c478bd9Sstevel@tonic-gate data_type_t type; 14277c478bd9Sstevel@tonic-gate void *val; 14287c478bd9Sstevel@tonic-gate uint_t *nelem; 14297c478bd9Sstevel@tonic-gate 14307c478bd9Sstevel@tonic-gate switch (type = va_arg(ap, data_type_t)) { 14317c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 14327c478bd9Sstevel@tonic-gate ret = nvlist_lookup_common(nvl, name, type, NULL, NULL); 14337c478bd9Sstevel@tonic-gate break; 14347c478bd9Sstevel@tonic-gate 14357c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 14367c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE: 14377c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8: 14387c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8: 14397c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16: 14407c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16: 14417c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32: 14427c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32: 14437c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64: 14447c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64: 14457c478bd9Sstevel@tonic-gate case DATA_TYPE_HRTIME: 14467c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING: 14477c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 14487c478bd9Sstevel@tonic-gate val = va_arg(ap, void *); 14497c478bd9Sstevel@tonic-gate ret = nvlist_lookup_common(nvl, name, type, NULL, val); 14507c478bd9Sstevel@tonic-gate break; 14517c478bd9Sstevel@tonic-gate 14527c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE_ARRAY: 14537c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: 14547c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8_ARRAY: 14557c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8_ARRAY: 14567c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16_ARRAY: 14577c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16_ARRAY: 14587c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32_ARRAY: 14597c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32_ARRAY: 14607c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64_ARRAY: 14617c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64_ARRAY: 14627c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: 14637c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: 14647c478bd9Sstevel@tonic-gate val = va_arg(ap, void *); 14657c478bd9Sstevel@tonic-gate nelem = va_arg(ap, uint_t *); 14667c478bd9Sstevel@tonic-gate ret = nvlist_lookup_common(nvl, name, type, nelem, val); 14677c478bd9Sstevel@tonic-gate break; 14687c478bd9Sstevel@tonic-gate 14697c478bd9Sstevel@tonic-gate default: 14707c478bd9Sstevel@tonic-gate ret = EINVAL; 14717c478bd9Sstevel@tonic-gate } 14727c478bd9Sstevel@tonic-gate 14737c478bd9Sstevel@tonic-gate if (ret == ENOENT && noentok) 14747c478bd9Sstevel@tonic-gate ret = 0; 14757c478bd9Sstevel@tonic-gate } 14767c478bd9Sstevel@tonic-gate va_end(ap); 14777c478bd9Sstevel@tonic-gate 14787c478bd9Sstevel@tonic-gate return (ret); 14797c478bd9Sstevel@tonic-gate } 14807c478bd9Sstevel@tonic-gate 14817c478bd9Sstevel@tonic-gate int 14827c478bd9Sstevel@tonic-gate nvpair_value_boolean_value(nvpair_t *nvp, boolean_t *val) 14837c478bd9Sstevel@tonic-gate { 14847c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_BOOLEAN_VALUE, NULL, val)); 14857c478bd9Sstevel@tonic-gate } 14867c478bd9Sstevel@tonic-gate 14877c478bd9Sstevel@tonic-gate int 14887c478bd9Sstevel@tonic-gate nvpair_value_byte(nvpair_t *nvp, uchar_t *val) 14897c478bd9Sstevel@tonic-gate { 14907c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_BYTE, NULL, val)); 14917c478bd9Sstevel@tonic-gate } 14927c478bd9Sstevel@tonic-gate 14937c478bd9Sstevel@tonic-gate int 14947c478bd9Sstevel@tonic-gate nvpair_value_int8(nvpair_t *nvp, int8_t *val) 14957c478bd9Sstevel@tonic-gate { 14967c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT8, NULL, val)); 14977c478bd9Sstevel@tonic-gate } 14987c478bd9Sstevel@tonic-gate 14997c478bd9Sstevel@tonic-gate int 15007c478bd9Sstevel@tonic-gate nvpair_value_uint8(nvpair_t *nvp, uint8_t *val) 15017c478bd9Sstevel@tonic-gate { 15027c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT8, NULL, val)); 15037c478bd9Sstevel@tonic-gate } 15047c478bd9Sstevel@tonic-gate 15057c478bd9Sstevel@tonic-gate int 15067c478bd9Sstevel@tonic-gate nvpair_value_int16(nvpair_t *nvp, int16_t *val) 15077c478bd9Sstevel@tonic-gate { 15087c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT16, NULL, val)); 15097c478bd9Sstevel@tonic-gate } 15107c478bd9Sstevel@tonic-gate 15117c478bd9Sstevel@tonic-gate int 15127c478bd9Sstevel@tonic-gate nvpair_value_uint16(nvpair_t *nvp, uint16_t *val) 15137c478bd9Sstevel@tonic-gate { 15147c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT16, NULL, val)); 15157c478bd9Sstevel@tonic-gate } 15167c478bd9Sstevel@tonic-gate 15177c478bd9Sstevel@tonic-gate int 15187c478bd9Sstevel@tonic-gate nvpair_value_int32(nvpair_t *nvp, int32_t *val) 15197c478bd9Sstevel@tonic-gate { 15207c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT32, NULL, val)); 15217c478bd9Sstevel@tonic-gate } 15227c478bd9Sstevel@tonic-gate 15237c478bd9Sstevel@tonic-gate int 15247c478bd9Sstevel@tonic-gate nvpair_value_uint32(nvpair_t *nvp, uint32_t *val) 15257c478bd9Sstevel@tonic-gate { 15267c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT32, NULL, val)); 15277c478bd9Sstevel@tonic-gate } 15287c478bd9Sstevel@tonic-gate 15297c478bd9Sstevel@tonic-gate int 15307c478bd9Sstevel@tonic-gate nvpair_value_int64(nvpair_t *nvp, int64_t *val) 15317c478bd9Sstevel@tonic-gate { 15327c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT64, NULL, val)); 15337c478bd9Sstevel@tonic-gate } 15347c478bd9Sstevel@tonic-gate 15357c478bd9Sstevel@tonic-gate int 15367c478bd9Sstevel@tonic-gate nvpair_value_uint64(nvpair_t *nvp, uint64_t *val) 15377c478bd9Sstevel@tonic-gate { 15387c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT64, NULL, val)); 15397c478bd9Sstevel@tonic-gate } 15407c478bd9Sstevel@tonic-gate 15417c478bd9Sstevel@tonic-gate int 15427c478bd9Sstevel@tonic-gate nvpair_value_string(nvpair_t *nvp, char **val) 15437c478bd9Sstevel@tonic-gate { 15447c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_STRING, NULL, val)); 15457c478bd9Sstevel@tonic-gate } 15467c478bd9Sstevel@tonic-gate 15477c478bd9Sstevel@tonic-gate int 15487c478bd9Sstevel@tonic-gate nvpair_value_nvlist(nvpair_t *nvp, nvlist_t **val) 15497c478bd9Sstevel@tonic-gate { 15507c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_NVLIST, NULL, val)); 15517c478bd9Sstevel@tonic-gate } 15527c478bd9Sstevel@tonic-gate 15537c478bd9Sstevel@tonic-gate int 15547c478bd9Sstevel@tonic-gate nvpair_value_boolean_array(nvpair_t *nvp, boolean_t **val, uint_t *nelem) 15557c478bd9Sstevel@tonic-gate { 15567c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_BOOLEAN_ARRAY, nelem, val)); 15577c478bd9Sstevel@tonic-gate } 15587c478bd9Sstevel@tonic-gate 15597c478bd9Sstevel@tonic-gate int 15607c478bd9Sstevel@tonic-gate nvpair_value_byte_array(nvpair_t *nvp, uchar_t **val, uint_t *nelem) 15617c478bd9Sstevel@tonic-gate { 15627c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_BYTE_ARRAY, nelem, val)); 15637c478bd9Sstevel@tonic-gate } 15647c478bd9Sstevel@tonic-gate 15657c478bd9Sstevel@tonic-gate int 15667c478bd9Sstevel@tonic-gate nvpair_value_int8_array(nvpair_t *nvp, int8_t **val, uint_t *nelem) 15677c478bd9Sstevel@tonic-gate { 15687c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT8_ARRAY, nelem, val)); 15697c478bd9Sstevel@tonic-gate } 15707c478bd9Sstevel@tonic-gate 15717c478bd9Sstevel@tonic-gate int 15727c478bd9Sstevel@tonic-gate nvpair_value_uint8_array(nvpair_t *nvp, uint8_t **val, uint_t *nelem) 15737c478bd9Sstevel@tonic-gate { 15747c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT8_ARRAY, nelem, val)); 15757c478bd9Sstevel@tonic-gate } 15767c478bd9Sstevel@tonic-gate 15777c478bd9Sstevel@tonic-gate int 15787c478bd9Sstevel@tonic-gate nvpair_value_int16_array(nvpair_t *nvp, int16_t **val, uint_t *nelem) 15797c478bd9Sstevel@tonic-gate { 15807c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT16_ARRAY, nelem, val)); 15817c478bd9Sstevel@tonic-gate } 15827c478bd9Sstevel@tonic-gate 15837c478bd9Sstevel@tonic-gate int 15847c478bd9Sstevel@tonic-gate nvpair_value_uint16_array(nvpair_t *nvp, uint16_t **val, uint_t *nelem) 15857c478bd9Sstevel@tonic-gate { 15867c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT16_ARRAY, nelem, val)); 15877c478bd9Sstevel@tonic-gate } 15887c478bd9Sstevel@tonic-gate 15897c478bd9Sstevel@tonic-gate int 15907c478bd9Sstevel@tonic-gate nvpair_value_int32_array(nvpair_t *nvp, int32_t **val, uint_t *nelem) 15917c478bd9Sstevel@tonic-gate { 15927c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT32_ARRAY, nelem, val)); 15937c478bd9Sstevel@tonic-gate } 15947c478bd9Sstevel@tonic-gate 15957c478bd9Sstevel@tonic-gate int 15967c478bd9Sstevel@tonic-gate nvpair_value_uint32_array(nvpair_t *nvp, uint32_t **val, uint_t *nelem) 15977c478bd9Sstevel@tonic-gate { 15987c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT32_ARRAY, nelem, val)); 15997c478bd9Sstevel@tonic-gate } 16007c478bd9Sstevel@tonic-gate 16017c478bd9Sstevel@tonic-gate int 16027c478bd9Sstevel@tonic-gate nvpair_value_int64_array(nvpair_t *nvp, int64_t **val, uint_t *nelem) 16037c478bd9Sstevel@tonic-gate { 16047c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_INT64_ARRAY, nelem, val)); 16057c478bd9Sstevel@tonic-gate } 16067c478bd9Sstevel@tonic-gate 16077c478bd9Sstevel@tonic-gate int 16087c478bd9Sstevel@tonic-gate nvpair_value_uint64_array(nvpair_t *nvp, uint64_t **val, uint_t *nelem) 16097c478bd9Sstevel@tonic-gate { 16107c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_UINT64_ARRAY, nelem, val)); 16117c478bd9Sstevel@tonic-gate } 16127c478bd9Sstevel@tonic-gate 16137c478bd9Sstevel@tonic-gate int 16147c478bd9Sstevel@tonic-gate nvpair_value_string_array(nvpair_t *nvp, char ***val, uint_t *nelem) 16157c478bd9Sstevel@tonic-gate { 16167c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_STRING_ARRAY, nelem, val)); 16177c478bd9Sstevel@tonic-gate } 16187c478bd9Sstevel@tonic-gate 16197c478bd9Sstevel@tonic-gate int 16207c478bd9Sstevel@tonic-gate nvpair_value_nvlist_array(nvpair_t *nvp, nvlist_t ***val, uint_t *nelem) 16217c478bd9Sstevel@tonic-gate { 16227c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_NVLIST_ARRAY, nelem, val)); 16237c478bd9Sstevel@tonic-gate } 16247c478bd9Sstevel@tonic-gate 16257c478bd9Sstevel@tonic-gate int 16267c478bd9Sstevel@tonic-gate nvpair_value_hrtime(nvpair_t *nvp, hrtime_t *val) 16277c478bd9Sstevel@tonic-gate { 16287c478bd9Sstevel@tonic-gate return (nvpair_value_common(nvp, DATA_TYPE_HRTIME, NULL, val)); 16297c478bd9Sstevel@tonic-gate } 16307c478bd9Sstevel@tonic-gate 16317c478bd9Sstevel@tonic-gate /* 16327c478bd9Sstevel@tonic-gate * Add specified pair to the list. 16337c478bd9Sstevel@tonic-gate */ 16347c478bd9Sstevel@tonic-gate int 16357c478bd9Sstevel@tonic-gate nvlist_add_nvpair(nvlist_t *nvl, nvpair_t *nvp) 16367c478bd9Sstevel@tonic-gate { 16377c478bd9Sstevel@tonic-gate if (nvl == NULL || nvp == NULL) 16387c478bd9Sstevel@tonic-gate return (EINVAL); 16397c478bd9Sstevel@tonic-gate 16407c478bd9Sstevel@tonic-gate return (nvlist_add_common(nvl, NVP_NAME(nvp), NVP_TYPE(nvp), 16417c478bd9Sstevel@tonic-gate NVP_NELEM(nvp), NVP_VALUE(nvp))); 16427c478bd9Sstevel@tonic-gate } 16437c478bd9Sstevel@tonic-gate 16447c478bd9Sstevel@tonic-gate /* 16457c478bd9Sstevel@tonic-gate * Merge the supplied nvlists and put the result in dst. 16467c478bd9Sstevel@tonic-gate * The merged list will contain all names specified in both lists, 16477c478bd9Sstevel@tonic-gate * the values are taken from nvl in the case of duplicates. 16487c478bd9Sstevel@tonic-gate * Return 0 on success. 16497c478bd9Sstevel@tonic-gate */ 16507c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 16517c478bd9Sstevel@tonic-gate int 16527c478bd9Sstevel@tonic-gate nvlist_merge(nvlist_t *dst, nvlist_t *nvl, int flag) 16537c478bd9Sstevel@tonic-gate { 16547c478bd9Sstevel@tonic-gate if (nvl == NULL || dst == NULL) 16557c478bd9Sstevel@tonic-gate return (EINVAL); 16567c478bd9Sstevel@tonic-gate 16577c478bd9Sstevel@tonic-gate if (dst != nvl) 16587c478bd9Sstevel@tonic-gate return (nvlist_copy_pairs(nvl, dst)); 16597c478bd9Sstevel@tonic-gate 16607c478bd9Sstevel@tonic-gate return (0); 16617c478bd9Sstevel@tonic-gate } 16627c478bd9Sstevel@tonic-gate 16637c478bd9Sstevel@tonic-gate /* 16647c478bd9Sstevel@tonic-gate * Encoding related routines 16657c478bd9Sstevel@tonic-gate */ 16667c478bd9Sstevel@tonic-gate #define NVS_OP_ENCODE 0 16677c478bd9Sstevel@tonic-gate #define NVS_OP_DECODE 1 16687c478bd9Sstevel@tonic-gate #define NVS_OP_GETSIZE 2 16697c478bd9Sstevel@tonic-gate 16707c478bd9Sstevel@tonic-gate typedef struct nvs_ops nvs_ops_t; 16717c478bd9Sstevel@tonic-gate 16727c478bd9Sstevel@tonic-gate typedef struct { 16737c478bd9Sstevel@tonic-gate int nvs_op; 16747c478bd9Sstevel@tonic-gate const nvs_ops_t *nvs_ops; 16757c478bd9Sstevel@tonic-gate void *nvs_private; 16767c478bd9Sstevel@tonic-gate nvpriv_t *nvs_priv; 16777c478bd9Sstevel@tonic-gate } nvstream_t; 16787c478bd9Sstevel@tonic-gate 16797c478bd9Sstevel@tonic-gate /* 16807c478bd9Sstevel@tonic-gate * nvs operations are: 16817c478bd9Sstevel@tonic-gate * - nvs_nvlist 16827c478bd9Sstevel@tonic-gate * encoding / decoding of a nvlist header (nvlist_t) 16837c478bd9Sstevel@tonic-gate * calculates the size used for header and end detection 16847c478bd9Sstevel@tonic-gate * 16857c478bd9Sstevel@tonic-gate * - nvs_nvpair 16867c478bd9Sstevel@tonic-gate * responsible for the first part of encoding / decoding of an nvpair 16877c478bd9Sstevel@tonic-gate * calculates the decoded size of an nvpair 16887c478bd9Sstevel@tonic-gate * 16897c478bd9Sstevel@tonic-gate * - nvs_nvp_op 16907c478bd9Sstevel@tonic-gate * second part of encoding / decoding of an nvpair 16917c478bd9Sstevel@tonic-gate * 16927c478bd9Sstevel@tonic-gate * - nvs_nvp_size 16937c478bd9Sstevel@tonic-gate * calculates the encoding size of an nvpair 16947c478bd9Sstevel@tonic-gate * 16957c478bd9Sstevel@tonic-gate * - nvs_nvl_fini 16967c478bd9Sstevel@tonic-gate * encodes the end detection mark (zeros). 16977c478bd9Sstevel@tonic-gate */ 16987c478bd9Sstevel@tonic-gate struct nvs_ops { 16997c478bd9Sstevel@tonic-gate int (*nvs_nvlist)(nvstream_t *, nvlist_t *, size_t *); 17007c478bd9Sstevel@tonic-gate int (*nvs_nvpair)(nvstream_t *, nvpair_t *, size_t *); 17017c478bd9Sstevel@tonic-gate int (*nvs_nvp_op)(nvstream_t *, nvpair_t *); 17027c478bd9Sstevel@tonic-gate int (*nvs_nvp_size)(nvstream_t *, nvpair_t *, size_t *); 17037c478bd9Sstevel@tonic-gate int (*nvs_nvl_fini)(nvstream_t *); 17047c478bd9Sstevel@tonic-gate }; 17057c478bd9Sstevel@tonic-gate 17067c478bd9Sstevel@tonic-gate typedef struct { 17077c478bd9Sstevel@tonic-gate char nvh_encoding; /* nvs encoding method */ 17087c478bd9Sstevel@tonic-gate char nvh_endian; /* nvs endian */ 17097c478bd9Sstevel@tonic-gate char nvh_reserved1; /* reserved for future use */ 17107c478bd9Sstevel@tonic-gate char nvh_reserved2; /* reserved for future use */ 17117c478bd9Sstevel@tonic-gate } nvs_header_t; 17127c478bd9Sstevel@tonic-gate 17137c478bd9Sstevel@tonic-gate static int 17147c478bd9Sstevel@tonic-gate nvs_encode_pairs(nvstream_t *nvs, nvlist_t *nvl) 17157c478bd9Sstevel@tonic-gate { 17167c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 17177c478bd9Sstevel@tonic-gate i_nvp_t *curr; 17187c478bd9Sstevel@tonic-gate 17197c478bd9Sstevel@tonic-gate /* 17207c478bd9Sstevel@tonic-gate * Walk nvpair in list and encode each nvpair 17217c478bd9Sstevel@tonic-gate */ 17227c478bd9Sstevel@tonic-gate for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) 17237c478bd9Sstevel@tonic-gate if (nvs->nvs_ops->nvs_nvpair(nvs, &curr->nvi_nvp, NULL) != 0) 17247c478bd9Sstevel@tonic-gate return (EFAULT); 17257c478bd9Sstevel@tonic-gate 17267c478bd9Sstevel@tonic-gate return (nvs->nvs_ops->nvs_nvl_fini(nvs)); 17277c478bd9Sstevel@tonic-gate } 17287c478bd9Sstevel@tonic-gate 17297c478bd9Sstevel@tonic-gate static int 17307c478bd9Sstevel@tonic-gate nvs_decode_pairs(nvstream_t *nvs, nvlist_t *nvl) 17317c478bd9Sstevel@tonic-gate { 17327c478bd9Sstevel@tonic-gate nvpair_t *nvp; 17337c478bd9Sstevel@tonic-gate size_t nvsize; 17347c478bd9Sstevel@tonic-gate int err; 17357c478bd9Sstevel@tonic-gate 17367c478bd9Sstevel@tonic-gate /* 17377c478bd9Sstevel@tonic-gate * Get decoded size of next pair in stream, alloc 17387c478bd9Sstevel@tonic-gate * memory for nvpair_t, then decode the nvpair 17397c478bd9Sstevel@tonic-gate */ 17407c478bd9Sstevel@tonic-gate while ((err = nvs->nvs_ops->nvs_nvpair(nvs, NULL, &nvsize)) == 0) { 17417c478bd9Sstevel@tonic-gate if (nvsize == 0) /* end of list */ 17427c478bd9Sstevel@tonic-gate break; 17437c478bd9Sstevel@tonic-gate 17447c478bd9Sstevel@tonic-gate /* make sure len makes sense */ 17457c478bd9Sstevel@tonic-gate if (nvsize < NVP_SIZE_CALC(1, 0)) 17467c478bd9Sstevel@tonic-gate return (EFAULT); 17477c478bd9Sstevel@tonic-gate 17487c478bd9Sstevel@tonic-gate if ((nvp = nvp_buf_alloc(nvl, nvsize)) == NULL) 17497c478bd9Sstevel@tonic-gate return (ENOMEM); 17507c478bd9Sstevel@tonic-gate 17517c478bd9Sstevel@tonic-gate if ((err = nvs->nvs_ops->nvs_nvp_op(nvs, nvp)) != 0) { 17527c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 17537c478bd9Sstevel@tonic-gate return (err); 17547c478bd9Sstevel@tonic-gate } 17557c478bd9Sstevel@tonic-gate 17567c478bd9Sstevel@tonic-gate if (i_validate_nvpair(nvp) != 0) { 17577c478bd9Sstevel@tonic-gate nvpair_free(nvp); 17587c478bd9Sstevel@tonic-gate nvp_buf_free(nvl, nvp); 17597c478bd9Sstevel@tonic-gate return (EFAULT); 17607c478bd9Sstevel@tonic-gate } 17617c478bd9Sstevel@tonic-gate 17627c478bd9Sstevel@tonic-gate nvp_buf_link(nvl, nvp); 17637c478bd9Sstevel@tonic-gate } 17647c478bd9Sstevel@tonic-gate return (err); 17657c478bd9Sstevel@tonic-gate } 17667c478bd9Sstevel@tonic-gate 17677c478bd9Sstevel@tonic-gate static int 17687c478bd9Sstevel@tonic-gate nvs_getsize_pairs(nvstream_t *nvs, nvlist_t *nvl, size_t *buflen) 17697c478bd9Sstevel@tonic-gate { 17707c478bd9Sstevel@tonic-gate nvpriv_t *priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv; 17717c478bd9Sstevel@tonic-gate i_nvp_t *curr; 17727c478bd9Sstevel@tonic-gate uint64_t nvsize = *buflen; 17737c478bd9Sstevel@tonic-gate size_t size; 17747c478bd9Sstevel@tonic-gate 17757c478bd9Sstevel@tonic-gate /* 17767c478bd9Sstevel@tonic-gate * Get encoded size of nvpairs in nvlist 17777c478bd9Sstevel@tonic-gate */ 17787c478bd9Sstevel@tonic-gate for (curr = priv->nvp_list; curr != NULL; curr = curr->nvi_next) { 17797c478bd9Sstevel@tonic-gate if (nvs->nvs_ops->nvs_nvp_size(nvs, &curr->nvi_nvp, &size) != 0) 17807c478bd9Sstevel@tonic-gate return (EINVAL); 17817c478bd9Sstevel@tonic-gate 17827c478bd9Sstevel@tonic-gate if ((nvsize += size) > INT32_MAX) 17837c478bd9Sstevel@tonic-gate return (EINVAL); 17847c478bd9Sstevel@tonic-gate } 17857c478bd9Sstevel@tonic-gate 17867c478bd9Sstevel@tonic-gate *buflen = nvsize; 17877c478bd9Sstevel@tonic-gate return (0); 17887c478bd9Sstevel@tonic-gate } 17897c478bd9Sstevel@tonic-gate 17907c478bd9Sstevel@tonic-gate static int 17917c478bd9Sstevel@tonic-gate nvs_operation(nvstream_t *nvs, nvlist_t *nvl, size_t *buflen) 17927c478bd9Sstevel@tonic-gate { 17937c478bd9Sstevel@tonic-gate int err; 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate if (nvl->nvl_priv == NULL) 17967c478bd9Sstevel@tonic-gate return (EFAULT); 17977c478bd9Sstevel@tonic-gate 17987c478bd9Sstevel@tonic-gate /* 17997c478bd9Sstevel@tonic-gate * Perform the operation, starting with header, then each nvpair 18007c478bd9Sstevel@tonic-gate */ 18017c478bd9Sstevel@tonic-gate if ((err = nvs->nvs_ops->nvs_nvlist(nvs, nvl, buflen)) != 0) 18027c478bd9Sstevel@tonic-gate return (err); 18037c478bd9Sstevel@tonic-gate 18047c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 18057c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 18067c478bd9Sstevel@tonic-gate err = nvs_encode_pairs(nvs, nvl); 18077c478bd9Sstevel@tonic-gate break; 18087c478bd9Sstevel@tonic-gate 18097c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 18107c478bd9Sstevel@tonic-gate err = nvs_decode_pairs(nvs, nvl); 18117c478bd9Sstevel@tonic-gate break; 18127c478bd9Sstevel@tonic-gate 18137c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: 18147c478bd9Sstevel@tonic-gate err = nvs_getsize_pairs(nvs, nvl, buflen); 18157c478bd9Sstevel@tonic-gate break; 18167c478bd9Sstevel@tonic-gate 18177c478bd9Sstevel@tonic-gate default: 18187c478bd9Sstevel@tonic-gate err = EINVAL; 18197c478bd9Sstevel@tonic-gate } 18207c478bd9Sstevel@tonic-gate 18217c478bd9Sstevel@tonic-gate return (err); 18227c478bd9Sstevel@tonic-gate } 18237c478bd9Sstevel@tonic-gate 18247c478bd9Sstevel@tonic-gate static int 18257c478bd9Sstevel@tonic-gate nvs_embedded(nvstream_t *nvs, nvlist_t *embedded) 18267c478bd9Sstevel@tonic-gate { 18277c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 18287c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 18297c478bd9Sstevel@tonic-gate return (nvs_operation(nvs, embedded, NULL)); 18307c478bd9Sstevel@tonic-gate 18317c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: { 18327c478bd9Sstevel@tonic-gate nvpriv_t *priv; 18337c478bd9Sstevel@tonic-gate int err; 18347c478bd9Sstevel@tonic-gate 18357c478bd9Sstevel@tonic-gate if (embedded->nvl_version != NV_VERSION) 18367c478bd9Sstevel@tonic-gate return (ENOTSUP); 18377c478bd9Sstevel@tonic-gate 18387c478bd9Sstevel@tonic-gate if ((priv = nv_priv_alloc_embedded(nvs->nvs_priv)) == NULL) 18397c478bd9Sstevel@tonic-gate return (ENOMEM); 18407c478bd9Sstevel@tonic-gate 18417c478bd9Sstevel@tonic-gate nvlist_init(embedded, embedded->nvl_nvflag, priv); 18427c478bd9Sstevel@tonic-gate 18437c478bd9Sstevel@tonic-gate if ((err = nvs_operation(nvs, embedded, NULL)) != 0) 18447c478bd9Sstevel@tonic-gate nvlist_free(embedded); 18457c478bd9Sstevel@tonic-gate return (err); 18467c478bd9Sstevel@tonic-gate } 18477c478bd9Sstevel@tonic-gate default: 18487c478bd9Sstevel@tonic-gate break; 18497c478bd9Sstevel@tonic-gate } 18507c478bd9Sstevel@tonic-gate 18517c478bd9Sstevel@tonic-gate return (EINVAL); 18527c478bd9Sstevel@tonic-gate } 18537c478bd9Sstevel@tonic-gate 18547c478bd9Sstevel@tonic-gate static int 18557c478bd9Sstevel@tonic-gate nvs_embedded_nvl_array(nvstream_t *nvs, nvpair_t *nvp, size_t *size) 18567c478bd9Sstevel@tonic-gate { 18577c478bd9Sstevel@tonic-gate size_t nelem = NVP_NELEM(nvp); 18587c478bd9Sstevel@tonic-gate nvlist_t **nvlp = EMBEDDED_NVL_ARRAY(nvp); 18597c478bd9Sstevel@tonic-gate int i; 18607c478bd9Sstevel@tonic-gate 18617c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 18627c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 18637c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) 18647c478bd9Sstevel@tonic-gate if (nvs_embedded(nvs, nvlp[i]) != 0) 18657c478bd9Sstevel@tonic-gate return (EFAULT); 18667c478bd9Sstevel@tonic-gate break; 18677c478bd9Sstevel@tonic-gate 18687c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: { 18697c478bd9Sstevel@tonic-gate size_t len = nelem * sizeof (uint64_t); 18707c478bd9Sstevel@tonic-gate nvlist_t *embedded = (nvlist_t *)((uintptr_t)nvlp + len); 18717c478bd9Sstevel@tonic-gate 18727c478bd9Sstevel@tonic-gate bzero(nvlp, len); /* don't trust packed data */ 18737c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 18747c478bd9Sstevel@tonic-gate if (nvs_embedded(nvs, embedded) != 0) { 18757c478bd9Sstevel@tonic-gate nvpair_free(nvp); 18767c478bd9Sstevel@tonic-gate return (EFAULT); 18777c478bd9Sstevel@tonic-gate } 18787c478bd9Sstevel@tonic-gate 18797c478bd9Sstevel@tonic-gate nvlp[i] = embedded++; 18807c478bd9Sstevel@tonic-gate } 18817c478bd9Sstevel@tonic-gate break; 18827c478bd9Sstevel@tonic-gate } 18837c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: { 18847c478bd9Sstevel@tonic-gate uint64_t nvsize = 0; 18857c478bd9Sstevel@tonic-gate 18867c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 18877c478bd9Sstevel@tonic-gate size_t nvp_sz = 0; 18887c478bd9Sstevel@tonic-gate 18897c478bd9Sstevel@tonic-gate if (nvs_operation(nvs, nvlp[i], &nvp_sz) != 0) 18907c478bd9Sstevel@tonic-gate return (EINVAL); 18917c478bd9Sstevel@tonic-gate 18927c478bd9Sstevel@tonic-gate if ((nvsize += nvp_sz) > INT32_MAX) 18937c478bd9Sstevel@tonic-gate return (EINVAL); 18947c478bd9Sstevel@tonic-gate } 18957c478bd9Sstevel@tonic-gate 18967c478bd9Sstevel@tonic-gate *size = nvsize; 18977c478bd9Sstevel@tonic-gate break; 18987c478bd9Sstevel@tonic-gate } 18997c478bd9Sstevel@tonic-gate default: 19007c478bd9Sstevel@tonic-gate return (EINVAL); 19017c478bd9Sstevel@tonic-gate } 19027c478bd9Sstevel@tonic-gate 19037c478bd9Sstevel@tonic-gate return (0); 19047c478bd9Sstevel@tonic-gate } 19057c478bd9Sstevel@tonic-gate 19067c478bd9Sstevel@tonic-gate static int nvs_native(nvstream_t *, nvlist_t *, char *, size_t *); 19077c478bd9Sstevel@tonic-gate static int nvs_xdr(nvstream_t *, nvlist_t *, char *, size_t *); 19087c478bd9Sstevel@tonic-gate 19097c478bd9Sstevel@tonic-gate /* 19107c478bd9Sstevel@tonic-gate * Common routine for nvlist operations: 19117c478bd9Sstevel@tonic-gate * encode, decode, getsize (encoded size). 19127c478bd9Sstevel@tonic-gate */ 19137c478bd9Sstevel@tonic-gate static int 19147c478bd9Sstevel@tonic-gate nvlist_common(nvlist_t *nvl, char *buf, size_t *buflen, int encoding, 19157c478bd9Sstevel@tonic-gate int nvs_op) 19167c478bd9Sstevel@tonic-gate { 19177c478bd9Sstevel@tonic-gate int err = 0; 19187c478bd9Sstevel@tonic-gate nvstream_t nvs; 19197c478bd9Sstevel@tonic-gate int nvl_endian; 19207c478bd9Sstevel@tonic-gate #ifdef _LITTLE_ENDIAN 19217c478bd9Sstevel@tonic-gate int host_endian = 1; 19227c478bd9Sstevel@tonic-gate #else 19237c478bd9Sstevel@tonic-gate int host_endian = 0; 19247c478bd9Sstevel@tonic-gate #endif /* _LITTLE_ENDIAN */ 19257c478bd9Sstevel@tonic-gate nvs_header_t *nvh = (void *)buf; 19267c478bd9Sstevel@tonic-gate 19277c478bd9Sstevel@tonic-gate if (buflen == NULL || nvl == NULL || 19287c478bd9Sstevel@tonic-gate (nvs.nvs_priv = (nvpriv_t *)(uintptr_t)nvl->nvl_priv) == NULL) 19297c478bd9Sstevel@tonic-gate return (EINVAL); 19307c478bd9Sstevel@tonic-gate 19317c478bd9Sstevel@tonic-gate nvs.nvs_op = nvs_op; 19327c478bd9Sstevel@tonic-gate 19337c478bd9Sstevel@tonic-gate /* 19347c478bd9Sstevel@tonic-gate * For NVS_OP_ENCODE and NVS_OP_DECODE make sure an nvlist and 19357c478bd9Sstevel@tonic-gate * a buffer is allocated. The first 4 bytes in the buffer are 19367c478bd9Sstevel@tonic-gate * used for encoding method and host endian. 19377c478bd9Sstevel@tonic-gate */ 19387c478bd9Sstevel@tonic-gate switch (nvs_op) { 19397c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 19407c478bd9Sstevel@tonic-gate if (buf == NULL || *buflen < sizeof (nvs_header_t)) 19417c478bd9Sstevel@tonic-gate return (EINVAL); 19427c478bd9Sstevel@tonic-gate 19437c478bd9Sstevel@tonic-gate nvh->nvh_encoding = encoding; 19447c478bd9Sstevel@tonic-gate nvh->nvh_endian = nvl_endian = host_endian; 19457c478bd9Sstevel@tonic-gate nvh->nvh_reserved1 = 0; 19467c478bd9Sstevel@tonic-gate nvh->nvh_reserved2 = 0; 19477c478bd9Sstevel@tonic-gate break; 19487c478bd9Sstevel@tonic-gate 19497c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 19507c478bd9Sstevel@tonic-gate if (buf == NULL || *buflen < sizeof (nvs_header_t)) 19517c478bd9Sstevel@tonic-gate return (EINVAL); 19527c478bd9Sstevel@tonic-gate 19537c478bd9Sstevel@tonic-gate /* get method of encoding from first byte */ 19547c478bd9Sstevel@tonic-gate encoding = nvh->nvh_encoding; 19557c478bd9Sstevel@tonic-gate nvl_endian = nvh->nvh_endian; 19567c478bd9Sstevel@tonic-gate break; 19577c478bd9Sstevel@tonic-gate 19587c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: 19597c478bd9Sstevel@tonic-gate nvl_endian = host_endian; 19607c478bd9Sstevel@tonic-gate 19617c478bd9Sstevel@tonic-gate /* 19627c478bd9Sstevel@tonic-gate * add the size for encoding 19637c478bd9Sstevel@tonic-gate */ 19647c478bd9Sstevel@tonic-gate *buflen = sizeof (nvs_header_t); 19657c478bd9Sstevel@tonic-gate break; 19667c478bd9Sstevel@tonic-gate 19677c478bd9Sstevel@tonic-gate default: 19687c478bd9Sstevel@tonic-gate return (ENOTSUP); 19697c478bd9Sstevel@tonic-gate } 19707c478bd9Sstevel@tonic-gate 19717c478bd9Sstevel@tonic-gate /* 19727c478bd9Sstevel@tonic-gate * Create an nvstream with proper encoding method 19737c478bd9Sstevel@tonic-gate */ 19747c478bd9Sstevel@tonic-gate switch (encoding) { 19757c478bd9Sstevel@tonic-gate case NV_ENCODE_NATIVE: 19767c478bd9Sstevel@tonic-gate /* 19777c478bd9Sstevel@tonic-gate * check endianness, in case we are unpacking 19787c478bd9Sstevel@tonic-gate * from a file 19797c478bd9Sstevel@tonic-gate */ 19807c478bd9Sstevel@tonic-gate if (nvl_endian != host_endian) 19817c478bd9Sstevel@tonic-gate return (ENOTSUP); 19827c478bd9Sstevel@tonic-gate err = nvs_native(&nvs, nvl, buf, buflen); 19837c478bd9Sstevel@tonic-gate break; 19847c478bd9Sstevel@tonic-gate case NV_ENCODE_XDR: 19857c478bd9Sstevel@tonic-gate err = nvs_xdr(&nvs, nvl, buf, buflen); 19867c478bd9Sstevel@tonic-gate break; 19877c478bd9Sstevel@tonic-gate default: 19887c478bd9Sstevel@tonic-gate err = ENOTSUP; 19897c478bd9Sstevel@tonic-gate break; 19907c478bd9Sstevel@tonic-gate } 19917c478bd9Sstevel@tonic-gate 19927c478bd9Sstevel@tonic-gate return (err); 19937c478bd9Sstevel@tonic-gate } 19947c478bd9Sstevel@tonic-gate 19957c478bd9Sstevel@tonic-gate int 19967c478bd9Sstevel@tonic-gate nvlist_size(nvlist_t *nvl, size_t *size, int encoding) 19977c478bd9Sstevel@tonic-gate { 19987c478bd9Sstevel@tonic-gate return (nvlist_common(nvl, NULL, size, encoding, NVS_OP_GETSIZE)); 19997c478bd9Sstevel@tonic-gate } 20007c478bd9Sstevel@tonic-gate 20017c478bd9Sstevel@tonic-gate /* 20027c478bd9Sstevel@tonic-gate * Pack nvlist into contiguous memory 20037c478bd9Sstevel@tonic-gate */ 20047c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 20057c478bd9Sstevel@tonic-gate int 20067c478bd9Sstevel@tonic-gate nvlist_pack(nvlist_t *nvl, char **bufp, size_t *buflen, int encoding, 20077c478bd9Sstevel@tonic-gate int kmflag) 20087c478bd9Sstevel@tonic-gate { 20097c478bd9Sstevel@tonic-gate #if defined(_KERNEL) && !defined(_BOOT) 20107c478bd9Sstevel@tonic-gate return (nvlist_xpack(nvl, bufp, buflen, encoding, 20117c478bd9Sstevel@tonic-gate (kmflag == KM_SLEEP ? nv_alloc_sleep : nv_alloc_nosleep))); 20127c478bd9Sstevel@tonic-gate #else 20137c478bd9Sstevel@tonic-gate return (nvlist_xpack(nvl, bufp, buflen, encoding, nv_alloc_nosleep)); 20147c478bd9Sstevel@tonic-gate #endif 20157c478bd9Sstevel@tonic-gate } 20167c478bd9Sstevel@tonic-gate 20177c478bd9Sstevel@tonic-gate int 20187c478bd9Sstevel@tonic-gate nvlist_xpack(nvlist_t *nvl, char **bufp, size_t *buflen, int encoding, 20197c478bd9Sstevel@tonic-gate nv_alloc_t *nva) 20207c478bd9Sstevel@tonic-gate { 20217c478bd9Sstevel@tonic-gate nvpriv_t nvpriv; 20227c478bd9Sstevel@tonic-gate size_t alloc_size; 20237c478bd9Sstevel@tonic-gate char *buf; 20247c478bd9Sstevel@tonic-gate int err; 20257c478bd9Sstevel@tonic-gate 20267c478bd9Sstevel@tonic-gate if (nva == NULL || nvl == NULL || bufp == NULL || buflen == NULL) 20277c478bd9Sstevel@tonic-gate return (EINVAL); 20287c478bd9Sstevel@tonic-gate 20297c478bd9Sstevel@tonic-gate if (*bufp != NULL) 20307c478bd9Sstevel@tonic-gate return (nvlist_common(nvl, *bufp, buflen, encoding, 20317c478bd9Sstevel@tonic-gate NVS_OP_ENCODE)); 20327c478bd9Sstevel@tonic-gate 20337c478bd9Sstevel@tonic-gate /* 20347c478bd9Sstevel@tonic-gate * Here is a difficult situation: 20357c478bd9Sstevel@tonic-gate * 1. The nvlist has fixed allocator properties. 20367c478bd9Sstevel@tonic-gate * All other nvlist routines (like nvlist_add_*, ...) use 20377c478bd9Sstevel@tonic-gate * these properties. 20387c478bd9Sstevel@tonic-gate * 2. When using nvlist_pack() the user can specify his own 20397c478bd9Sstevel@tonic-gate * allocator properties (e.g. by using KM_NOSLEEP). 20407c478bd9Sstevel@tonic-gate * 20417c478bd9Sstevel@tonic-gate * We use the user specified properties (2). A clearer solution 20427c478bd9Sstevel@tonic-gate * will be to remove the kmflag from nvlist_pack(), but we will 20437c478bd9Sstevel@tonic-gate * not change the interface. 20447c478bd9Sstevel@tonic-gate */ 20457c478bd9Sstevel@tonic-gate nv_priv_init(&nvpriv, nva, 0); 20467c478bd9Sstevel@tonic-gate 20477c478bd9Sstevel@tonic-gate if (err = nvlist_size(nvl, &alloc_size, encoding)) 20487c478bd9Sstevel@tonic-gate return (err); 20497c478bd9Sstevel@tonic-gate 20507c478bd9Sstevel@tonic-gate if ((buf = nv_mem_zalloc(&nvpriv, alloc_size)) == NULL) 20517c478bd9Sstevel@tonic-gate return (ENOMEM); 20527c478bd9Sstevel@tonic-gate 20537c478bd9Sstevel@tonic-gate if ((err = nvlist_common(nvl, buf, &alloc_size, encoding, 20547c478bd9Sstevel@tonic-gate NVS_OP_ENCODE)) != 0) { 20557c478bd9Sstevel@tonic-gate nv_mem_free(&nvpriv, buf, alloc_size); 20567c478bd9Sstevel@tonic-gate } else { 20577c478bd9Sstevel@tonic-gate *buflen = alloc_size; 20587c478bd9Sstevel@tonic-gate *bufp = buf; 20597c478bd9Sstevel@tonic-gate } 20607c478bd9Sstevel@tonic-gate 20617c478bd9Sstevel@tonic-gate return (err); 20627c478bd9Sstevel@tonic-gate } 20637c478bd9Sstevel@tonic-gate 20647c478bd9Sstevel@tonic-gate /* 20657c478bd9Sstevel@tonic-gate * Unpack buf into an nvlist_t 20667c478bd9Sstevel@tonic-gate */ 20677c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 20687c478bd9Sstevel@tonic-gate int 20697c478bd9Sstevel@tonic-gate nvlist_unpack(char *buf, size_t buflen, nvlist_t **nvlp, int kmflag) 20707c478bd9Sstevel@tonic-gate { 20717c478bd9Sstevel@tonic-gate #if defined(_KERNEL) && !defined(_BOOT) 20727c478bd9Sstevel@tonic-gate return (nvlist_xunpack(buf, buflen, nvlp, 20737c478bd9Sstevel@tonic-gate (kmflag == KM_SLEEP ? nv_alloc_sleep : nv_alloc_nosleep))); 20747c478bd9Sstevel@tonic-gate #else 20757c478bd9Sstevel@tonic-gate return (nvlist_xunpack(buf, buflen, nvlp, nv_alloc_nosleep)); 20767c478bd9Sstevel@tonic-gate #endif 20777c478bd9Sstevel@tonic-gate } 20787c478bd9Sstevel@tonic-gate 20797c478bd9Sstevel@tonic-gate int 20807c478bd9Sstevel@tonic-gate nvlist_xunpack(char *buf, size_t buflen, nvlist_t **nvlp, nv_alloc_t *nva) 20817c478bd9Sstevel@tonic-gate { 20827c478bd9Sstevel@tonic-gate nvlist_t *nvl; 20837c478bd9Sstevel@tonic-gate int err; 20847c478bd9Sstevel@tonic-gate 20857c478bd9Sstevel@tonic-gate if (nvlp == NULL) 20867c478bd9Sstevel@tonic-gate return (EINVAL); 20877c478bd9Sstevel@tonic-gate 20887c478bd9Sstevel@tonic-gate if ((err = nvlist_xalloc(&nvl, 0, nva)) != 0) 20897c478bd9Sstevel@tonic-gate return (err); 20907c478bd9Sstevel@tonic-gate 20917c478bd9Sstevel@tonic-gate if ((err = nvlist_common(nvl, buf, &buflen, 0, NVS_OP_DECODE)) != 0) 20927c478bd9Sstevel@tonic-gate nvlist_free(nvl); 20937c478bd9Sstevel@tonic-gate else 20947c478bd9Sstevel@tonic-gate *nvlp = nvl; 20957c478bd9Sstevel@tonic-gate 20967c478bd9Sstevel@tonic-gate return (err); 20977c478bd9Sstevel@tonic-gate } 20987c478bd9Sstevel@tonic-gate 20997c478bd9Sstevel@tonic-gate /* 21007c478bd9Sstevel@tonic-gate * Native encoding functions 21017c478bd9Sstevel@tonic-gate */ 21027c478bd9Sstevel@tonic-gate typedef struct { 21037c478bd9Sstevel@tonic-gate /* 21047c478bd9Sstevel@tonic-gate * This structure is used when decoding a packed nvpair in 21057c478bd9Sstevel@tonic-gate * the native format. n_base points to a buffer containing the 21067c478bd9Sstevel@tonic-gate * packed nvpair. n_end is a pointer to the end of the buffer. 21077c478bd9Sstevel@tonic-gate * (n_end actually points to the first byte past the end of the 21087c478bd9Sstevel@tonic-gate * buffer.) n_curr is a pointer that lies between n_base and n_end. 21097c478bd9Sstevel@tonic-gate * It points to the current data that we are decoding. 21107c478bd9Sstevel@tonic-gate * The amount of data left in the buffer is equal to n_end - n_curr. 21117c478bd9Sstevel@tonic-gate * n_flag is used to recognize a packed embedded list. 21127c478bd9Sstevel@tonic-gate */ 21137c478bd9Sstevel@tonic-gate caddr_t n_base; 21147c478bd9Sstevel@tonic-gate caddr_t n_end; 21157c478bd9Sstevel@tonic-gate caddr_t n_curr; 21167c478bd9Sstevel@tonic-gate uint_t n_flag; 21177c478bd9Sstevel@tonic-gate } nvs_native_t; 21187c478bd9Sstevel@tonic-gate 21197c478bd9Sstevel@tonic-gate static int 21207c478bd9Sstevel@tonic-gate nvs_native_create(nvstream_t *nvs, nvs_native_t *native, char *buf, 21217c478bd9Sstevel@tonic-gate size_t buflen) 21227c478bd9Sstevel@tonic-gate { 21237c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 21247c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 21257c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 21267c478bd9Sstevel@tonic-gate nvs->nvs_private = native; 21277c478bd9Sstevel@tonic-gate native->n_curr = native->n_base = buf; 21287c478bd9Sstevel@tonic-gate native->n_end = buf + buflen; 21297c478bd9Sstevel@tonic-gate native->n_flag = 0; 21307c478bd9Sstevel@tonic-gate return (0); 21317c478bd9Sstevel@tonic-gate 21327c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: 21337c478bd9Sstevel@tonic-gate nvs->nvs_private = native; 21347c478bd9Sstevel@tonic-gate native->n_curr = native->n_base = native->n_end = NULL; 21357c478bd9Sstevel@tonic-gate native->n_flag = 0; 21367c478bd9Sstevel@tonic-gate return (0); 21377c478bd9Sstevel@tonic-gate default: 21387c478bd9Sstevel@tonic-gate return (EINVAL); 21397c478bd9Sstevel@tonic-gate } 21407c478bd9Sstevel@tonic-gate } 21417c478bd9Sstevel@tonic-gate 21427c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 21437c478bd9Sstevel@tonic-gate static void 21447c478bd9Sstevel@tonic-gate nvs_native_destroy(nvstream_t *nvs) 21457c478bd9Sstevel@tonic-gate { 21467c478bd9Sstevel@tonic-gate } 21477c478bd9Sstevel@tonic-gate 21487c478bd9Sstevel@tonic-gate static int 21497c478bd9Sstevel@tonic-gate native_cp(nvstream_t *nvs, void *buf, size_t size) 21507c478bd9Sstevel@tonic-gate { 21517c478bd9Sstevel@tonic-gate nvs_native_t *native = (nvs_native_t *)nvs->nvs_private; 21527c478bd9Sstevel@tonic-gate 21537c478bd9Sstevel@tonic-gate if (native->n_curr + size > native->n_end) 21547c478bd9Sstevel@tonic-gate return (EFAULT); 21557c478bd9Sstevel@tonic-gate 21567c478bd9Sstevel@tonic-gate /* 21577c478bd9Sstevel@tonic-gate * The bcopy() below eliminates alignment requirement 21587c478bd9Sstevel@tonic-gate * on the buffer (stream) and is preferred over direct access. 21597c478bd9Sstevel@tonic-gate */ 21607c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 21617c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 21627c478bd9Sstevel@tonic-gate bcopy(buf, native->n_curr, size); 21637c478bd9Sstevel@tonic-gate break; 21647c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 21657c478bd9Sstevel@tonic-gate bcopy(native->n_curr, buf, size); 21667c478bd9Sstevel@tonic-gate break; 21677c478bd9Sstevel@tonic-gate default: 21687c478bd9Sstevel@tonic-gate return (EINVAL); 21697c478bd9Sstevel@tonic-gate } 21707c478bd9Sstevel@tonic-gate 21717c478bd9Sstevel@tonic-gate native->n_curr += size; 21727c478bd9Sstevel@tonic-gate return (0); 21737c478bd9Sstevel@tonic-gate } 21747c478bd9Sstevel@tonic-gate 21757c478bd9Sstevel@tonic-gate /* 21767c478bd9Sstevel@tonic-gate * operate on nvlist_t header 21777c478bd9Sstevel@tonic-gate */ 21787c478bd9Sstevel@tonic-gate static int 21797c478bd9Sstevel@tonic-gate nvs_native_nvlist(nvstream_t *nvs, nvlist_t *nvl, size_t *size) 21807c478bd9Sstevel@tonic-gate { 21817c478bd9Sstevel@tonic-gate nvs_native_t *native = nvs->nvs_private; 21827c478bd9Sstevel@tonic-gate 21837c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 21847c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 21857c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 21867c478bd9Sstevel@tonic-gate if (native->n_flag) 21877c478bd9Sstevel@tonic-gate return (0); /* packed embedded list */ 21887c478bd9Sstevel@tonic-gate 21897c478bd9Sstevel@tonic-gate native->n_flag = 1; 21907c478bd9Sstevel@tonic-gate 21917c478bd9Sstevel@tonic-gate /* copy version and nvflag of the nvlist_t */ 21927c478bd9Sstevel@tonic-gate if (native_cp(nvs, &nvl->nvl_version, sizeof (int32_t)) != 0 || 21937c478bd9Sstevel@tonic-gate native_cp(nvs, &nvl->nvl_nvflag, sizeof (int32_t)) != 0) 21947c478bd9Sstevel@tonic-gate return (EFAULT); 21957c478bd9Sstevel@tonic-gate 21967c478bd9Sstevel@tonic-gate return (0); 21977c478bd9Sstevel@tonic-gate 21987c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: 21997c478bd9Sstevel@tonic-gate /* 22007c478bd9Sstevel@tonic-gate * if calculate for packed embedded list 22017c478bd9Sstevel@tonic-gate * 4 for end of the embedded list 22027c478bd9Sstevel@tonic-gate * else 22037c478bd9Sstevel@tonic-gate * 2 * sizeof (int32_t) for nvl_version and nvl_nvflag 22047c478bd9Sstevel@tonic-gate * and 4 for end of the entire list 22057c478bd9Sstevel@tonic-gate */ 22067c478bd9Sstevel@tonic-gate if (native->n_flag) { 22077c478bd9Sstevel@tonic-gate *size += 4; 22087c478bd9Sstevel@tonic-gate } else { 22097c478bd9Sstevel@tonic-gate native->n_flag = 1; 22107c478bd9Sstevel@tonic-gate *size += 2 * sizeof (int32_t) + 4; 22117c478bd9Sstevel@tonic-gate } 22127c478bd9Sstevel@tonic-gate 22137c478bd9Sstevel@tonic-gate return (0); 22147c478bd9Sstevel@tonic-gate 22157c478bd9Sstevel@tonic-gate default: 22167c478bd9Sstevel@tonic-gate return (EINVAL); 22177c478bd9Sstevel@tonic-gate } 22187c478bd9Sstevel@tonic-gate } 22197c478bd9Sstevel@tonic-gate 22207c478bd9Sstevel@tonic-gate static int 22217c478bd9Sstevel@tonic-gate nvs_native_nvl_fini(nvstream_t *nvs) 22227c478bd9Sstevel@tonic-gate { 22237c478bd9Sstevel@tonic-gate if (nvs->nvs_op == NVS_OP_ENCODE) { 22247c478bd9Sstevel@tonic-gate nvs_native_t *native = (nvs_native_t *)nvs->nvs_private; 22257c478bd9Sstevel@tonic-gate /* 22267c478bd9Sstevel@tonic-gate * Add 4 zero bytes at end of nvlist. They are used 22277c478bd9Sstevel@tonic-gate * for end detection by the decode routine. 22287c478bd9Sstevel@tonic-gate */ 22297c478bd9Sstevel@tonic-gate if (native->n_curr + sizeof (int) > native->n_end) 22307c478bd9Sstevel@tonic-gate return (EFAULT); 22317c478bd9Sstevel@tonic-gate 22327c478bd9Sstevel@tonic-gate bzero(native->n_curr, sizeof (int)); 22337c478bd9Sstevel@tonic-gate native->n_curr += sizeof (int); 22347c478bd9Sstevel@tonic-gate } 22357c478bd9Sstevel@tonic-gate 22367c478bd9Sstevel@tonic-gate return (0); 22377c478bd9Sstevel@tonic-gate } 22387c478bd9Sstevel@tonic-gate 22397c478bd9Sstevel@tonic-gate static int 22407c478bd9Sstevel@tonic-gate nvpair_native_embedded(nvstream_t *nvs, nvpair_t *nvp) 22417c478bd9Sstevel@tonic-gate { 22427c478bd9Sstevel@tonic-gate if (nvs->nvs_op == NVS_OP_ENCODE) { 22437c478bd9Sstevel@tonic-gate nvs_native_t *native = (nvs_native_t *)nvs->nvs_private; 22447c478bd9Sstevel@tonic-gate nvlist_t *packed = (void *) 22457c478bd9Sstevel@tonic-gate (native->n_curr - nvp->nvp_size + NVP_VALOFF(nvp)); 22467c478bd9Sstevel@tonic-gate /* 22477c478bd9Sstevel@tonic-gate * Null out the pointer that is meaningless in the packed 22487c478bd9Sstevel@tonic-gate * structure. The address may not be aligned, so we have 22497c478bd9Sstevel@tonic-gate * to use bzero. 22507c478bd9Sstevel@tonic-gate */ 22517c478bd9Sstevel@tonic-gate bzero(&packed->nvl_priv, sizeof (packed->nvl_priv)); 22527c478bd9Sstevel@tonic-gate } 22537c478bd9Sstevel@tonic-gate 22547c478bd9Sstevel@tonic-gate return (nvs_embedded(nvs, EMBEDDED_NVL(nvp))); 22557c478bd9Sstevel@tonic-gate } 22567c478bd9Sstevel@tonic-gate 22577c478bd9Sstevel@tonic-gate static int 22587c478bd9Sstevel@tonic-gate nvpair_native_embedded_array(nvstream_t *nvs, nvpair_t *nvp) 22597c478bd9Sstevel@tonic-gate { 22607c478bd9Sstevel@tonic-gate if (nvs->nvs_op == NVS_OP_ENCODE) { 22617c478bd9Sstevel@tonic-gate nvs_native_t *native = (nvs_native_t *)nvs->nvs_private; 22627c478bd9Sstevel@tonic-gate char *value = native->n_curr - nvp->nvp_size + NVP_VALOFF(nvp); 22637c478bd9Sstevel@tonic-gate size_t len = NVP_NELEM(nvp) * sizeof (uint64_t); 22647c478bd9Sstevel@tonic-gate nvlist_t *packed = (nvlist_t *)((uintptr_t)value + len); 22657c478bd9Sstevel@tonic-gate int i; 22667c478bd9Sstevel@tonic-gate /* 22677c478bd9Sstevel@tonic-gate * Null out pointers that are meaningless in the packed 22687c478bd9Sstevel@tonic-gate * structure. The addresses may not be aligned, so we have 22697c478bd9Sstevel@tonic-gate * to use bzero. 22707c478bd9Sstevel@tonic-gate */ 22717c478bd9Sstevel@tonic-gate bzero(value, len); 22727c478bd9Sstevel@tonic-gate 22737c478bd9Sstevel@tonic-gate for (i = 0; i < NVP_NELEM(nvp); i++, packed++) 22747c478bd9Sstevel@tonic-gate /* 22757c478bd9Sstevel@tonic-gate * Null out the pointer that is meaningless in the 22767c478bd9Sstevel@tonic-gate * packed structure. The address may not be aligned, 22777c478bd9Sstevel@tonic-gate * so we have to use bzero. 22787c478bd9Sstevel@tonic-gate */ 22797c478bd9Sstevel@tonic-gate bzero(&packed->nvl_priv, sizeof (packed->nvl_priv)); 22807c478bd9Sstevel@tonic-gate } 22817c478bd9Sstevel@tonic-gate 22827c478bd9Sstevel@tonic-gate return (nvs_embedded_nvl_array(nvs, nvp, NULL)); 22837c478bd9Sstevel@tonic-gate } 22847c478bd9Sstevel@tonic-gate 22857c478bd9Sstevel@tonic-gate static void 22867c478bd9Sstevel@tonic-gate nvpair_native_string_array(nvstream_t *nvs, nvpair_t *nvp) 22877c478bd9Sstevel@tonic-gate { 22887c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 22897c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: { 22907c478bd9Sstevel@tonic-gate nvs_native_t *native = (nvs_native_t *)nvs->nvs_private; 22917c478bd9Sstevel@tonic-gate uint64_t *strp = (void *) 22927c478bd9Sstevel@tonic-gate (native->n_curr - nvp->nvp_size + NVP_VALOFF(nvp)); 22937c478bd9Sstevel@tonic-gate /* 22947c478bd9Sstevel@tonic-gate * Null out pointers that are meaningless in the packed 22957c478bd9Sstevel@tonic-gate * structure. The addresses may not be aligned, so we have 22967c478bd9Sstevel@tonic-gate * to use bzero. 22977c478bd9Sstevel@tonic-gate */ 22987c478bd9Sstevel@tonic-gate bzero(strp, NVP_NELEM(nvp) * sizeof (uint64_t)); 22997c478bd9Sstevel@tonic-gate break; 23007c478bd9Sstevel@tonic-gate } 23017c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: { 23027c478bd9Sstevel@tonic-gate char **strp = (void *)NVP_VALUE(nvp); 23037c478bd9Sstevel@tonic-gate char *buf = ((char *)strp + NVP_NELEM(nvp) * sizeof (uint64_t)); 23047c478bd9Sstevel@tonic-gate int i; 23057c478bd9Sstevel@tonic-gate 23067c478bd9Sstevel@tonic-gate for (i = 0; i < NVP_NELEM(nvp); i++) { 23077c478bd9Sstevel@tonic-gate strp[i] = buf; 23087c478bd9Sstevel@tonic-gate buf += strlen(buf) + 1; 23097c478bd9Sstevel@tonic-gate } 23107c478bd9Sstevel@tonic-gate break; 23117c478bd9Sstevel@tonic-gate } 23127c478bd9Sstevel@tonic-gate } 23137c478bd9Sstevel@tonic-gate } 23147c478bd9Sstevel@tonic-gate 23157c478bd9Sstevel@tonic-gate static int 23167c478bd9Sstevel@tonic-gate nvs_native_nvp_op(nvstream_t *nvs, nvpair_t *nvp) 23177c478bd9Sstevel@tonic-gate { 23187c478bd9Sstevel@tonic-gate data_type_t type; 23197c478bd9Sstevel@tonic-gate int value_sz; 23207c478bd9Sstevel@tonic-gate int ret = 0; 23217c478bd9Sstevel@tonic-gate 23227c478bd9Sstevel@tonic-gate /* 23237c478bd9Sstevel@tonic-gate * We do the initial bcopy of the data before we look at 23247c478bd9Sstevel@tonic-gate * the nvpair type, because when we're decoding, we won't 23257c478bd9Sstevel@tonic-gate * have the correct values for the pair until we do the bcopy. 23267c478bd9Sstevel@tonic-gate */ 23277c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 23287c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 23297c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 23307c478bd9Sstevel@tonic-gate if (native_cp(nvs, nvp, nvp->nvp_size) != 0) 23317c478bd9Sstevel@tonic-gate return (EFAULT); 23327c478bd9Sstevel@tonic-gate break; 23337c478bd9Sstevel@tonic-gate default: 23347c478bd9Sstevel@tonic-gate return (EINVAL); 23357c478bd9Sstevel@tonic-gate } 23367c478bd9Sstevel@tonic-gate 23377c478bd9Sstevel@tonic-gate /* verify nvp_name_sz, check the name string length */ 23387c478bd9Sstevel@tonic-gate if (i_validate_nvpair_name(nvp) != 0) 23397c478bd9Sstevel@tonic-gate return (EFAULT); 23407c478bd9Sstevel@tonic-gate 23417c478bd9Sstevel@tonic-gate type = NVP_TYPE(nvp); 23427c478bd9Sstevel@tonic-gate 23437c478bd9Sstevel@tonic-gate /* 23447c478bd9Sstevel@tonic-gate * Verify type and nelem and get the value size. 23457c478bd9Sstevel@tonic-gate * In case of data types DATA_TYPE_STRING and DATA_TYPE_STRING_ARRAY 23467c478bd9Sstevel@tonic-gate * is the size of the string(s) excluded. 23477c478bd9Sstevel@tonic-gate */ 23487c478bd9Sstevel@tonic-gate if ((value_sz = i_get_value_size(type, NULL, NVP_NELEM(nvp))) < 0) 23497c478bd9Sstevel@tonic-gate return (EFAULT); 23507c478bd9Sstevel@tonic-gate 23517c478bd9Sstevel@tonic-gate if (NVP_SIZE_CALC(nvp->nvp_name_sz, value_sz) > nvp->nvp_size) 23527c478bd9Sstevel@tonic-gate return (EFAULT); 23537c478bd9Sstevel@tonic-gate 23547c478bd9Sstevel@tonic-gate switch (type) { 23557c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 23567c478bd9Sstevel@tonic-gate ret = nvpair_native_embedded(nvs, nvp); 23577c478bd9Sstevel@tonic-gate break; 23587c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: 23597c478bd9Sstevel@tonic-gate ret = nvpair_native_embedded_array(nvs, nvp); 23607c478bd9Sstevel@tonic-gate break; 23617c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: 23627c478bd9Sstevel@tonic-gate nvpair_native_string_array(nvs, nvp); 23637c478bd9Sstevel@tonic-gate break; 23647c478bd9Sstevel@tonic-gate default: 23657c478bd9Sstevel@tonic-gate break; 23667c478bd9Sstevel@tonic-gate } 23677c478bd9Sstevel@tonic-gate 23687c478bd9Sstevel@tonic-gate return (ret); 23697c478bd9Sstevel@tonic-gate } 23707c478bd9Sstevel@tonic-gate 23717c478bd9Sstevel@tonic-gate static int 23727c478bd9Sstevel@tonic-gate nvs_native_nvp_size(nvstream_t *nvs, nvpair_t *nvp, size_t *size) 23737c478bd9Sstevel@tonic-gate { 23747c478bd9Sstevel@tonic-gate uint64_t nvp_sz = nvp->nvp_size; 23757c478bd9Sstevel@tonic-gate 23767c478bd9Sstevel@tonic-gate switch (NVP_TYPE(nvp)) { 23777c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: { 23787c478bd9Sstevel@tonic-gate size_t nvsize = 0; 23797c478bd9Sstevel@tonic-gate 23807c478bd9Sstevel@tonic-gate if (nvs_operation(nvs, EMBEDDED_NVL(nvp), &nvsize) != 0) 23817c478bd9Sstevel@tonic-gate return (EINVAL); 23827c478bd9Sstevel@tonic-gate 23837c478bd9Sstevel@tonic-gate nvp_sz += nvsize; 23847c478bd9Sstevel@tonic-gate break; 23857c478bd9Sstevel@tonic-gate } 23867c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: { 23877c478bd9Sstevel@tonic-gate size_t nvsize; 23887c478bd9Sstevel@tonic-gate 23897c478bd9Sstevel@tonic-gate if (nvs_embedded_nvl_array(nvs, nvp, &nvsize) != 0) 23907c478bd9Sstevel@tonic-gate return (EINVAL); 23917c478bd9Sstevel@tonic-gate 23927c478bd9Sstevel@tonic-gate nvp_sz += nvsize; 23937c478bd9Sstevel@tonic-gate break; 23947c478bd9Sstevel@tonic-gate } 23957c478bd9Sstevel@tonic-gate default: 23967c478bd9Sstevel@tonic-gate break; 23977c478bd9Sstevel@tonic-gate } 23987c478bd9Sstevel@tonic-gate 23997c478bd9Sstevel@tonic-gate if (nvp_sz > INT32_MAX) 24007c478bd9Sstevel@tonic-gate return (EINVAL); 24017c478bd9Sstevel@tonic-gate 24027c478bd9Sstevel@tonic-gate *size = nvp_sz; 24037c478bd9Sstevel@tonic-gate 24047c478bd9Sstevel@tonic-gate return (0); 24057c478bd9Sstevel@tonic-gate } 24067c478bd9Sstevel@tonic-gate 24077c478bd9Sstevel@tonic-gate static int 24087c478bd9Sstevel@tonic-gate nvs_native_nvpair(nvstream_t *nvs, nvpair_t *nvp, size_t *size) 24097c478bd9Sstevel@tonic-gate { 24107c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 24117c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 24127c478bd9Sstevel@tonic-gate return (nvs_native_nvp_op(nvs, nvp)); 24137c478bd9Sstevel@tonic-gate 24147c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: { 24157c478bd9Sstevel@tonic-gate nvs_native_t *native = (nvs_native_t *)nvs->nvs_private; 24167c478bd9Sstevel@tonic-gate int32_t decode_len; 24177c478bd9Sstevel@tonic-gate 24187c478bd9Sstevel@tonic-gate /* try to read the size value from the stream */ 24197c478bd9Sstevel@tonic-gate if (native->n_curr + sizeof (int32_t) > native->n_end) 24207c478bd9Sstevel@tonic-gate return (EFAULT); 24217c478bd9Sstevel@tonic-gate bcopy(native->n_curr, &decode_len, sizeof (int32_t)); 24227c478bd9Sstevel@tonic-gate 24237c478bd9Sstevel@tonic-gate /* sanity check the size value */ 24247c478bd9Sstevel@tonic-gate if (decode_len < 0 || 24257c478bd9Sstevel@tonic-gate decode_len > native->n_end - native->n_curr) 24267c478bd9Sstevel@tonic-gate return (EFAULT); 24277c478bd9Sstevel@tonic-gate 24287c478bd9Sstevel@tonic-gate *size = decode_len; 24297c478bd9Sstevel@tonic-gate 24307c478bd9Sstevel@tonic-gate /* 24317c478bd9Sstevel@tonic-gate * If at the end of the stream then move the cursor 24327c478bd9Sstevel@tonic-gate * forward, otherwise nvpair_native_op() will read 24337c478bd9Sstevel@tonic-gate * the entire nvpair at the same cursor position. 24347c478bd9Sstevel@tonic-gate */ 24357c478bd9Sstevel@tonic-gate if (*size == 0) 24367c478bd9Sstevel@tonic-gate native->n_curr += sizeof (int32_t); 24377c478bd9Sstevel@tonic-gate break; 24387c478bd9Sstevel@tonic-gate } 24397c478bd9Sstevel@tonic-gate 24407c478bd9Sstevel@tonic-gate default: 24417c478bd9Sstevel@tonic-gate return (EINVAL); 24427c478bd9Sstevel@tonic-gate } 24437c478bd9Sstevel@tonic-gate 24447c478bd9Sstevel@tonic-gate return (0); 24457c478bd9Sstevel@tonic-gate } 24467c478bd9Sstevel@tonic-gate 24477c478bd9Sstevel@tonic-gate static const nvs_ops_t nvs_native_ops = { 24487c478bd9Sstevel@tonic-gate nvs_native_nvlist, 24497c478bd9Sstevel@tonic-gate nvs_native_nvpair, 24507c478bd9Sstevel@tonic-gate nvs_native_nvp_op, 24517c478bd9Sstevel@tonic-gate nvs_native_nvp_size, 24527c478bd9Sstevel@tonic-gate nvs_native_nvl_fini 24537c478bd9Sstevel@tonic-gate }; 24547c478bd9Sstevel@tonic-gate 24557c478bd9Sstevel@tonic-gate static int 24567c478bd9Sstevel@tonic-gate nvs_native(nvstream_t *nvs, nvlist_t *nvl, char *buf, size_t *buflen) 24577c478bd9Sstevel@tonic-gate { 24587c478bd9Sstevel@tonic-gate nvs_native_t native; 24597c478bd9Sstevel@tonic-gate int err; 24607c478bd9Sstevel@tonic-gate 24617c478bd9Sstevel@tonic-gate nvs->nvs_ops = &nvs_native_ops; 24627c478bd9Sstevel@tonic-gate 24637c478bd9Sstevel@tonic-gate if ((err = nvs_native_create(nvs, &native, buf + sizeof (nvs_header_t), 24647c478bd9Sstevel@tonic-gate *buflen - sizeof (nvs_header_t))) != 0) 24657c478bd9Sstevel@tonic-gate return (err); 24667c478bd9Sstevel@tonic-gate 24677c478bd9Sstevel@tonic-gate err = nvs_operation(nvs, nvl, buflen); 24687c478bd9Sstevel@tonic-gate 24697c478bd9Sstevel@tonic-gate nvs_native_destroy(nvs); 24707c478bd9Sstevel@tonic-gate 24717c478bd9Sstevel@tonic-gate return (err); 24727c478bd9Sstevel@tonic-gate } 24737c478bd9Sstevel@tonic-gate 24747c478bd9Sstevel@tonic-gate /* 24757c478bd9Sstevel@tonic-gate * XDR encoding functions 24767c478bd9Sstevel@tonic-gate * 24777c478bd9Sstevel@tonic-gate * An xdr packed nvlist is encoded as: 24787c478bd9Sstevel@tonic-gate * 24797c478bd9Sstevel@tonic-gate * - encoding methode and host endian (4 bytes) 24807c478bd9Sstevel@tonic-gate * - nvl_version (4 bytes) 24817c478bd9Sstevel@tonic-gate * - nvl_nvflag (4 bytes) 24827c478bd9Sstevel@tonic-gate * 24837c478bd9Sstevel@tonic-gate * - encoded nvpairs, the format of one xdr encoded nvpair is: 24847c478bd9Sstevel@tonic-gate * - encoded size of the nvpair (4 bytes) 24857c478bd9Sstevel@tonic-gate * - decoded size of the nvpair (4 bytes) 24867c478bd9Sstevel@tonic-gate * - name string, (4 + sizeof(NV_ALIGN4(string)) 24877c478bd9Sstevel@tonic-gate * a string is coded as size (4 bytes) and data 24887c478bd9Sstevel@tonic-gate * - data type (4 bytes) 24897c478bd9Sstevel@tonic-gate * - number of elements in the nvpair (4 bytes) 24907c478bd9Sstevel@tonic-gate * - data 24917c478bd9Sstevel@tonic-gate * 24927c478bd9Sstevel@tonic-gate * - 2 zero's for end of the entire list (8 bytes) 24937c478bd9Sstevel@tonic-gate */ 24947c478bd9Sstevel@tonic-gate static int 24957c478bd9Sstevel@tonic-gate nvs_xdr_create(nvstream_t *nvs, XDR *xdr, char *buf, size_t buflen) 24967c478bd9Sstevel@tonic-gate { 24977c478bd9Sstevel@tonic-gate /* xdr data must be 4 byte aligned */ 24987c478bd9Sstevel@tonic-gate if ((ulong_t)buf % 4 != 0) 24997c478bd9Sstevel@tonic-gate return (EFAULT); 25007c478bd9Sstevel@tonic-gate 25017c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 25027c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 25037c478bd9Sstevel@tonic-gate xdrmem_create(xdr, buf, (uint_t)buflen, XDR_ENCODE); 25047c478bd9Sstevel@tonic-gate nvs->nvs_private = xdr; 25057c478bd9Sstevel@tonic-gate return (0); 25067c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 25077c478bd9Sstevel@tonic-gate xdrmem_create(xdr, buf, (uint_t)buflen, XDR_DECODE); 25087c478bd9Sstevel@tonic-gate nvs->nvs_private = xdr; 25097c478bd9Sstevel@tonic-gate return (0); 25107c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: 25117c478bd9Sstevel@tonic-gate nvs->nvs_private = NULL; 25127c478bd9Sstevel@tonic-gate return (0); 25137c478bd9Sstevel@tonic-gate default: 25147c478bd9Sstevel@tonic-gate return (EINVAL); 25157c478bd9Sstevel@tonic-gate } 25167c478bd9Sstevel@tonic-gate } 25177c478bd9Sstevel@tonic-gate 25187c478bd9Sstevel@tonic-gate static void 25197c478bd9Sstevel@tonic-gate nvs_xdr_destroy(nvstream_t *nvs) 25207c478bd9Sstevel@tonic-gate { 25217c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 25227c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 25237c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: 25247c478bd9Sstevel@tonic-gate xdr_destroy((XDR *)nvs->nvs_private); 25257c478bd9Sstevel@tonic-gate break; 25267c478bd9Sstevel@tonic-gate default: 25277c478bd9Sstevel@tonic-gate break; 25287c478bd9Sstevel@tonic-gate } 25297c478bd9Sstevel@tonic-gate } 25307c478bd9Sstevel@tonic-gate 25317c478bd9Sstevel@tonic-gate static int 25327c478bd9Sstevel@tonic-gate nvs_xdr_nvlist(nvstream_t *nvs, nvlist_t *nvl, size_t *size) 25337c478bd9Sstevel@tonic-gate { 25347c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 25357c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: 25367c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: { 25377c478bd9Sstevel@tonic-gate XDR *xdr = nvs->nvs_private; 25387c478bd9Sstevel@tonic-gate 25397c478bd9Sstevel@tonic-gate if (!xdr_int(xdr, &nvl->nvl_version) || 25407c478bd9Sstevel@tonic-gate !xdr_u_int(xdr, &nvl->nvl_nvflag)) 25417c478bd9Sstevel@tonic-gate return (EFAULT); 25427c478bd9Sstevel@tonic-gate break; 25437c478bd9Sstevel@tonic-gate } 25447c478bd9Sstevel@tonic-gate case NVS_OP_GETSIZE: { 25457c478bd9Sstevel@tonic-gate /* 25467c478bd9Sstevel@tonic-gate * 2 * 4 for nvl_version + nvl_nvflag 25477c478bd9Sstevel@tonic-gate * and 8 for end of the entire list 25487c478bd9Sstevel@tonic-gate */ 25497c478bd9Sstevel@tonic-gate *size += 2 * 4 + 8; 25507c478bd9Sstevel@tonic-gate break; 25517c478bd9Sstevel@tonic-gate } 25527c478bd9Sstevel@tonic-gate default: 25537c478bd9Sstevel@tonic-gate return (EINVAL); 25547c478bd9Sstevel@tonic-gate } 25557c478bd9Sstevel@tonic-gate return (0); 25567c478bd9Sstevel@tonic-gate } 25577c478bd9Sstevel@tonic-gate 25587c478bd9Sstevel@tonic-gate static int 25597c478bd9Sstevel@tonic-gate nvs_xdr_nvl_fini(nvstream_t *nvs) 25607c478bd9Sstevel@tonic-gate { 25617c478bd9Sstevel@tonic-gate if (nvs->nvs_op == NVS_OP_ENCODE) { 25627c478bd9Sstevel@tonic-gate XDR *xdr = nvs->nvs_private; 25637c478bd9Sstevel@tonic-gate int zero = 0; 25647c478bd9Sstevel@tonic-gate 25657c478bd9Sstevel@tonic-gate if (!xdr_int(xdr, &zero) || !xdr_int(xdr, &zero)) 25667c478bd9Sstevel@tonic-gate return (EFAULT); 25677c478bd9Sstevel@tonic-gate } 25687c478bd9Sstevel@tonic-gate 25697c478bd9Sstevel@tonic-gate return (0); 25707c478bd9Sstevel@tonic-gate } 25717c478bd9Sstevel@tonic-gate 25727c478bd9Sstevel@tonic-gate /* 25737c478bd9Sstevel@tonic-gate * The format of xdr encoded nvpair is: 25747c478bd9Sstevel@tonic-gate * encode_size, decode_size, name string, data type, nelem, data 25757c478bd9Sstevel@tonic-gate */ 25767c478bd9Sstevel@tonic-gate static int 25777c478bd9Sstevel@tonic-gate nvs_xdr_nvp_op(nvstream_t *nvs, nvpair_t *nvp) 25787c478bd9Sstevel@tonic-gate { 25797c478bd9Sstevel@tonic-gate data_type_t type; 25807c478bd9Sstevel@tonic-gate char *buf; 25817c478bd9Sstevel@tonic-gate char *buf_end = (char *)nvp + nvp->nvp_size; 25827c478bd9Sstevel@tonic-gate int value_sz; 25837c478bd9Sstevel@tonic-gate uint_t nelem, buflen; 25847c478bd9Sstevel@tonic-gate bool_t ret = FALSE; 25857c478bd9Sstevel@tonic-gate XDR *xdr = nvs->nvs_private; 25867c478bd9Sstevel@tonic-gate 25877c478bd9Sstevel@tonic-gate ASSERT(xdr != NULL && nvp != NULL); 25887c478bd9Sstevel@tonic-gate 25897c478bd9Sstevel@tonic-gate /* name string */ 25907c478bd9Sstevel@tonic-gate if ((buf = NVP_NAME(nvp)) >= buf_end) 25917c478bd9Sstevel@tonic-gate return (EFAULT); 25927c478bd9Sstevel@tonic-gate buflen = buf_end - buf; 25937c478bd9Sstevel@tonic-gate 25947c478bd9Sstevel@tonic-gate if (!xdr_string(xdr, &buf, buflen - 1)) 25957c478bd9Sstevel@tonic-gate return (EFAULT); 25967c478bd9Sstevel@tonic-gate nvp->nvp_name_sz = strlen(buf) + 1; 25977c478bd9Sstevel@tonic-gate 25987c478bd9Sstevel@tonic-gate /* type and nelem */ 25997c478bd9Sstevel@tonic-gate if (!xdr_int(xdr, (int *)&nvp->nvp_type) || 26007c478bd9Sstevel@tonic-gate !xdr_int(xdr, &nvp->nvp_value_elem)) 26017c478bd9Sstevel@tonic-gate return (EFAULT); 26027c478bd9Sstevel@tonic-gate 26037c478bd9Sstevel@tonic-gate type = NVP_TYPE(nvp); 26047c478bd9Sstevel@tonic-gate nelem = nvp->nvp_value_elem; 26057c478bd9Sstevel@tonic-gate 26067c478bd9Sstevel@tonic-gate /* 26077c478bd9Sstevel@tonic-gate * Verify type and nelem and get the value size. 26087c478bd9Sstevel@tonic-gate * In case of data types DATA_TYPE_STRING and DATA_TYPE_STRING_ARRAY 26097c478bd9Sstevel@tonic-gate * is the size of the string(s) excluded. 26107c478bd9Sstevel@tonic-gate */ 26117c478bd9Sstevel@tonic-gate if ((value_sz = i_get_value_size(type, NULL, nelem)) < 0) 26127c478bd9Sstevel@tonic-gate return (EFAULT); 26137c478bd9Sstevel@tonic-gate 26147c478bd9Sstevel@tonic-gate /* if there is no data to extract then return */ 26157c478bd9Sstevel@tonic-gate if (nelem == 0) 26167c478bd9Sstevel@tonic-gate return (0); 26177c478bd9Sstevel@tonic-gate 26187c478bd9Sstevel@tonic-gate /* value */ 26197c478bd9Sstevel@tonic-gate if ((buf = NVP_VALUE(nvp)) >= buf_end) 26207c478bd9Sstevel@tonic-gate return (EFAULT); 26217c478bd9Sstevel@tonic-gate buflen = buf_end - buf; 26227c478bd9Sstevel@tonic-gate 26237c478bd9Sstevel@tonic-gate if (buflen < value_sz) 26247c478bd9Sstevel@tonic-gate return (EFAULT); 26257c478bd9Sstevel@tonic-gate 26267c478bd9Sstevel@tonic-gate switch (type) { 26277c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 26287c478bd9Sstevel@tonic-gate if (nvs_embedded(nvs, (void *)buf) == 0) 26297c478bd9Sstevel@tonic-gate return (0); 26307c478bd9Sstevel@tonic-gate break; 26317c478bd9Sstevel@tonic-gate 26327c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: 26337c478bd9Sstevel@tonic-gate if (nvs_embedded_nvl_array(nvs, nvp, NULL) == 0) 26347c478bd9Sstevel@tonic-gate return (0); 26357c478bd9Sstevel@tonic-gate break; 26367c478bd9Sstevel@tonic-gate 26377c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 26387c478bd9Sstevel@tonic-gate ret = TRUE; 26397c478bd9Sstevel@tonic-gate break; 26407c478bd9Sstevel@tonic-gate 26417c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE: 26427c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8: 26437c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8: 26447c478bd9Sstevel@tonic-gate ret = xdr_char(xdr, buf); 26457c478bd9Sstevel@tonic-gate break; 26467c478bd9Sstevel@tonic-gate 26477c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16: 26487c478bd9Sstevel@tonic-gate ret = xdr_short(xdr, (void *)buf); 26497c478bd9Sstevel@tonic-gate break; 26507c478bd9Sstevel@tonic-gate 26517c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16: 26527c478bd9Sstevel@tonic-gate ret = xdr_u_short(xdr, (void *)buf); 26537c478bd9Sstevel@tonic-gate break; 26547c478bd9Sstevel@tonic-gate 26557c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 26567c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32: 26577c478bd9Sstevel@tonic-gate ret = xdr_int(xdr, (void *)buf); 26587c478bd9Sstevel@tonic-gate break; 26597c478bd9Sstevel@tonic-gate 26607c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32: 26617c478bd9Sstevel@tonic-gate ret = xdr_u_int(xdr, (void *)buf); 26627c478bd9Sstevel@tonic-gate break; 26637c478bd9Sstevel@tonic-gate 26647c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64: 26657c478bd9Sstevel@tonic-gate ret = xdr_longlong_t(xdr, (void *)buf); 26667c478bd9Sstevel@tonic-gate break; 26677c478bd9Sstevel@tonic-gate 26687c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64: 26697c478bd9Sstevel@tonic-gate ret = xdr_u_longlong_t(xdr, (void *)buf); 26707c478bd9Sstevel@tonic-gate break; 26717c478bd9Sstevel@tonic-gate 26727c478bd9Sstevel@tonic-gate case DATA_TYPE_HRTIME: 26737c478bd9Sstevel@tonic-gate /* 26747c478bd9Sstevel@tonic-gate * NOTE: must expose the definition of hrtime_t here 26757c478bd9Sstevel@tonic-gate */ 26767c478bd9Sstevel@tonic-gate ret = xdr_longlong_t(xdr, (void *)buf); 26777c478bd9Sstevel@tonic-gate break; 26787c478bd9Sstevel@tonic-gate 26797c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING: 26807c478bd9Sstevel@tonic-gate ret = xdr_string(xdr, &buf, buflen - 1); 26817c478bd9Sstevel@tonic-gate break; 26827c478bd9Sstevel@tonic-gate 26837c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE_ARRAY: 26847c478bd9Sstevel@tonic-gate ret = xdr_opaque(xdr, buf, nelem); 26857c478bd9Sstevel@tonic-gate break; 26867c478bd9Sstevel@tonic-gate 26877c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8_ARRAY: 26887c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8_ARRAY: 26897c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen, sizeof (int8_t), 26907c478bd9Sstevel@tonic-gate (xdrproc_t)xdr_char); 26917c478bd9Sstevel@tonic-gate break; 26927c478bd9Sstevel@tonic-gate 26937c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16_ARRAY: 26947c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (int16_t), 26957c478bd9Sstevel@tonic-gate sizeof (int16_t), (xdrproc_t)xdr_short); 26967c478bd9Sstevel@tonic-gate break; 26977c478bd9Sstevel@tonic-gate 26987c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16_ARRAY: 26997c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (uint16_t), 27007c478bd9Sstevel@tonic-gate sizeof (uint16_t), (xdrproc_t)xdr_u_short); 27017c478bd9Sstevel@tonic-gate break; 27027c478bd9Sstevel@tonic-gate 27037c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: 27047c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32_ARRAY: 27057c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (int32_t), 27067c478bd9Sstevel@tonic-gate sizeof (int32_t), (xdrproc_t)xdr_int); 27077c478bd9Sstevel@tonic-gate break; 27087c478bd9Sstevel@tonic-gate 27097c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32_ARRAY: 27107c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (uint32_t), 27117c478bd9Sstevel@tonic-gate sizeof (uint32_t), (xdrproc_t)xdr_u_int); 27127c478bd9Sstevel@tonic-gate break; 27137c478bd9Sstevel@tonic-gate 27147c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64_ARRAY: 27157c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (int64_t), 27167c478bd9Sstevel@tonic-gate sizeof (int64_t), (xdrproc_t)xdr_longlong_t); 27177c478bd9Sstevel@tonic-gate break; 27187c478bd9Sstevel@tonic-gate 27197c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64_ARRAY: 27207c478bd9Sstevel@tonic-gate ret = xdr_array(xdr, &buf, &nelem, buflen / sizeof (uint64_t), 27217c478bd9Sstevel@tonic-gate sizeof (uint64_t), (xdrproc_t)xdr_u_longlong_t); 27227c478bd9Sstevel@tonic-gate break; 27237c478bd9Sstevel@tonic-gate 27247c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: { 27257c478bd9Sstevel@tonic-gate size_t len = nelem * sizeof (uint64_t); 27267c478bd9Sstevel@tonic-gate char **strp = (void *)buf; 27277c478bd9Sstevel@tonic-gate int i; 27287c478bd9Sstevel@tonic-gate 27297c478bd9Sstevel@tonic-gate if (nvs->nvs_op == NVS_OP_DECODE) 27307c478bd9Sstevel@tonic-gate bzero(buf, len); /* don't trust packed data */ 27317c478bd9Sstevel@tonic-gate 27327c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 27337c478bd9Sstevel@tonic-gate if (buflen <= len) 27347c478bd9Sstevel@tonic-gate return (EFAULT); 27357c478bd9Sstevel@tonic-gate 27367c478bd9Sstevel@tonic-gate buf += len; 27377c478bd9Sstevel@tonic-gate buflen -= len; 27387c478bd9Sstevel@tonic-gate 27397c478bd9Sstevel@tonic-gate if (xdr_string(xdr, &buf, buflen - 1) != TRUE) 27407c478bd9Sstevel@tonic-gate return (EFAULT); 27417c478bd9Sstevel@tonic-gate 27427c478bd9Sstevel@tonic-gate if (nvs->nvs_op == NVS_OP_DECODE) 27437c478bd9Sstevel@tonic-gate strp[i] = buf; 27447c478bd9Sstevel@tonic-gate len = strlen(buf) + 1; 27457c478bd9Sstevel@tonic-gate } 27467c478bd9Sstevel@tonic-gate ret = TRUE; 27477c478bd9Sstevel@tonic-gate break; 27487c478bd9Sstevel@tonic-gate } 27497c478bd9Sstevel@tonic-gate default: 27507c478bd9Sstevel@tonic-gate break; 27517c478bd9Sstevel@tonic-gate } 27527c478bd9Sstevel@tonic-gate 27537c478bd9Sstevel@tonic-gate return (ret == TRUE ? 0 : EFAULT); 27547c478bd9Sstevel@tonic-gate } 27557c478bd9Sstevel@tonic-gate 27567c478bd9Sstevel@tonic-gate static int 27577c478bd9Sstevel@tonic-gate nvs_xdr_nvp_size(nvstream_t *nvs, nvpair_t *nvp, size_t *size) 27587c478bd9Sstevel@tonic-gate { 27597c478bd9Sstevel@tonic-gate data_type_t type = NVP_TYPE(nvp); 27607c478bd9Sstevel@tonic-gate /* 27617c478bd9Sstevel@tonic-gate * encode_size + decode_size + name string size + data type + nelem 27627c478bd9Sstevel@tonic-gate * where name string size = 4 + NV_ALIGN4(strlen(NVP_NAME(nvp))) 27637c478bd9Sstevel@tonic-gate */ 27647c478bd9Sstevel@tonic-gate uint64_t nvp_sz = 4 + 4 + 4 + NV_ALIGN4(strlen(NVP_NAME(nvp))) + 4 + 4; 27657c478bd9Sstevel@tonic-gate 27667c478bd9Sstevel@tonic-gate switch (type) { 27677c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN: 27687c478bd9Sstevel@tonic-gate break; 27697c478bd9Sstevel@tonic-gate 27707c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_VALUE: 27717c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE: 27727c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8: 27737c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8: 27747c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16: 27757c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16: 27767c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32: 27777c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32: 27787c478bd9Sstevel@tonic-gate nvp_sz += 4; /* 4 is the minimum xdr unit */ 27797c478bd9Sstevel@tonic-gate break; 27807c478bd9Sstevel@tonic-gate 27817c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64: 27827c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64: 27837c478bd9Sstevel@tonic-gate case DATA_TYPE_HRTIME: 27847c478bd9Sstevel@tonic-gate nvp_sz += 8; 27857c478bd9Sstevel@tonic-gate break; 27867c478bd9Sstevel@tonic-gate 27877c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING: 27887c478bd9Sstevel@tonic-gate nvp_sz += 4 + NV_ALIGN4(strlen((char *)NVP_VALUE(nvp))); 27897c478bd9Sstevel@tonic-gate break; 27907c478bd9Sstevel@tonic-gate 27917c478bd9Sstevel@tonic-gate case DATA_TYPE_BYTE_ARRAY: 27927c478bd9Sstevel@tonic-gate nvp_sz += NV_ALIGN4(NVP_NELEM(nvp)); 27937c478bd9Sstevel@tonic-gate break; 27947c478bd9Sstevel@tonic-gate 27957c478bd9Sstevel@tonic-gate case DATA_TYPE_BOOLEAN_ARRAY: 27967c478bd9Sstevel@tonic-gate case DATA_TYPE_INT8_ARRAY: 27977c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT8_ARRAY: 27987c478bd9Sstevel@tonic-gate case DATA_TYPE_INT16_ARRAY: 27997c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT16_ARRAY: 28007c478bd9Sstevel@tonic-gate case DATA_TYPE_INT32_ARRAY: 28017c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT32_ARRAY: 28027c478bd9Sstevel@tonic-gate nvp_sz += 4 + 4 * (uint64_t)NVP_NELEM(nvp); 28037c478bd9Sstevel@tonic-gate break; 28047c478bd9Sstevel@tonic-gate 28057c478bd9Sstevel@tonic-gate case DATA_TYPE_INT64_ARRAY: 28067c478bd9Sstevel@tonic-gate case DATA_TYPE_UINT64_ARRAY: 28077c478bd9Sstevel@tonic-gate nvp_sz += 4 + 8 * (uint64_t)NVP_NELEM(nvp); 28087c478bd9Sstevel@tonic-gate break; 28097c478bd9Sstevel@tonic-gate 28107c478bd9Sstevel@tonic-gate case DATA_TYPE_STRING_ARRAY: { 28117c478bd9Sstevel@tonic-gate int i; 28127c478bd9Sstevel@tonic-gate char **strs = (void *)NVP_VALUE(nvp); 28137c478bd9Sstevel@tonic-gate 28147c478bd9Sstevel@tonic-gate for (i = 0; i < NVP_NELEM(nvp); i++) 28157c478bd9Sstevel@tonic-gate nvp_sz += 4 + NV_ALIGN4(strlen(strs[i])); 28167c478bd9Sstevel@tonic-gate 28177c478bd9Sstevel@tonic-gate break; 28187c478bd9Sstevel@tonic-gate } 28197c478bd9Sstevel@tonic-gate 28207c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST: 28217c478bd9Sstevel@tonic-gate case DATA_TYPE_NVLIST_ARRAY: { 28227c478bd9Sstevel@tonic-gate size_t nvsize = 0; 28237c478bd9Sstevel@tonic-gate int old_nvs_op = nvs->nvs_op; 28247c478bd9Sstevel@tonic-gate int err; 28257c478bd9Sstevel@tonic-gate 28267c478bd9Sstevel@tonic-gate nvs->nvs_op = NVS_OP_GETSIZE; 28277c478bd9Sstevel@tonic-gate if (type == DATA_TYPE_NVLIST) 28287c478bd9Sstevel@tonic-gate err = nvs_operation(nvs, EMBEDDED_NVL(nvp), &nvsize); 28297c478bd9Sstevel@tonic-gate else 28307c478bd9Sstevel@tonic-gate err = nvs_embedded_nvl_array(nvs, nvp, &nvsize); 28317c478bd9Sstevel@tonic-gate nvs->nvs_op = old_nvs_op; 28327c478bd9Sstevel@tonic-gate 28337c478bd9Sstevel@tonic-gate if (err != 0) 28347c478bd9Sstevel@tonic-gate return (EINVAL); 28357c478bd9Sstevel@tonic-gate 28367c478bd9Sstevel@tonic-gate nvp_sz += nvsize; 28377c478bd9Sstevel@tonic-gate break; 28387c478bd9Sstevel@tonic-gate } 28397c478bd9Sstevel@tonic-gate 28407c478bd9Sstevel@tonic-gate default: 28417c478bd9Sstevel@tonic-gate return (EINVAL); 28427c478bd9Sstevel@tonic-gate } 28437c478bd9Sstevel@tonic-gate 28447c478bd9Sstevel@tonic-gate if (nvp_sz > INT32_MAX) 28457c478bd9Sstevel@tonic-gate return (EINVAL); 28467c478bd9Sstevel@tonic-gate 28477c478bd9Sstevel@tonic-gate *size = nvp_sz; 28487c478bd9Sstevel@tonic-gate 28497c478bd9Sstevel@tonic-gate return (0); 28507c478bd9Sstevel@tonic-gate } 28517c478bd9Sstevel@tonic-gate 28527c478bd9Sstevel@tonic-gate 28537c478bd9Sstevel@tonic-gate /* 28547c478bd9Sstevel@tonic-gate * The NVS_XDR_MAX_LEN macro takes a packed xdr buffer of size x and estimates 28557c478bd9Sstevel@tonic-gate * the largest nvpair that could be encoded in the buffer. 28567c478bd9Sstevel@tonic-gate * 28577c478bd9Sstevel@tonic-gate * See comments above nvpair_xdr_op() for the format of xdr encoding. 28587c478bd9Sstevel@tonic-gate * The size of a xdr packed nvpair without any data is 5 words. 28597c478bd9Sstevel@tonic-gate * 28607c478bd9Sstevel@tonic-gate * Using the size of the data directly as an estimate would be ok 28617c478bd9Sstevel@tonic-gate * in all cases except one. If the data type is of DATA_TYPE_STRING_ARRAY 28627c478bd9Sstevel@tonic-gate * then the actual nvpair has space for an array of pointers to index 28637c478bd9Sstevel@tonic-gate * the strings. These pointers are not encoded into the packed xdr buffer. 28647c478bd9Sstevel@tonic-gate * 28657c478bd9Sstevel@tonic-gate * If the data is of type DATA_TYPE_STRING_ARRAY and all the strings are 28667c478bd9Sstevel@tonic-gate * of length 0, then each string is endcoded in xdr format as a single word. 28677c478bd9Sstevel@tonic-gate * Therefore when expanded to an nvpair there will be 2.25 word used for 28687c478bd9Sstevel@tonic-gate * each string. (a int64_t allocated for pointer usage, and a single char 28697c478bd9Sstevel@tonic-gate * for the null termination.) 28707c478bd9Sstevel@tonic-gate * 28717c478bd9Sstevel@tonic-gate * This is the calculation performed by the NVS_XDR_MAX_LEN macro. 28727c478bd9Sstevel@tonic-gate */ 28737c478bd9Sstevel@tonic-gate #define NVS_XDR_HDR_LEN ((size_t)(5 * 4)) 28747c478bd9Sstevel@tonic-gate #define NVS_XDR_DATA_LEN(y) (((size_t)(y) <= NVS_XDR_HDR_LEN) ? \ 28757c478bd9Sstevel@tonic-gate 0 : ((size_t)(y) - NVS_XDR_HDR_LEN)) 28767c478bd9Sstevel@tonic-gate #define NVS_XDR_MAX_LEN(x) (NVP_SIZE_CALC(1, 0) + \ 28777c478bd9Sstevel@tonic-gate (NVS_XDR_DATA_LEN(x) * 2) + \ 28787c478bd9Sstevel@tonic-gate NV_ALIGN4((NVS_XDR_DATA_LEN(x) / 4))) 28797c478bd9Sstevel@tonic-gate 28807c478bd9Sstevel@tonic-gate static int 28817c478bd9Sstevel@tonic-gate nvs_xdr_nvpair(nvstream_t *nvs, nvpair_t *nvp, size_t *size) 28827c478bd9Sstevel@tonic-gate { 28837c478bd9Sstevel@tonic-gate XDR *xdr = nvs->nvs_private; 28847c478bd9Sstevel@tonic-gate int32_t encode_len, decode_len; 28857c478bd9Sstevel@tonic-gate 28867c478bd9Sstevel@tonic-gate switch (nvs->nvs_op) { 28877c478bd9Sstevel@tonic-gate case NVS_OP_ENCODE: { 28887c478bd9Sstevel@tonic-gate size_t nvsize; 28897c478bd9Sstevel@tonic-gate 28907c478bd9Sstevel@tonic-gate if (nvs_xdr_nvp_size(nvs, nvp, &nvsize) != 0) 28917c478bd9Sstevel@tonic-gate return (EFAULT); 28927c478bd9Sstevel@tonic-gate 28937c478bd9Sstevel@tonic-gate decode_len = nvp->nvp_size; 28947c478bd9Sstevel@tonic-gate encode_len = nvsize; 28957c478bd9Sstevel@tonic-gate if (!xdr_int(xdr, &encode_len) || !xdr_int(xdr, &decode_len)) 28967c478bd9Sstevel@tonic-gate return (EFAULT); 28977c478bd9Sstevel@tonic-gate 28987c478bd9Sstevel@tonic-gate return (nvs_xdr_nvp_op(nvs, nvp)); 28997c478bd9Sstevel@tonic-gate } 29007c478bd9Sstevel@tonic-gate case NVS_OP_DECODE: { 29017c478bd9Sstevel@tonic-gate struct xdr_bytesrec bytesrec; 29027c478bd9Sstevel@tonic-gate 29037c478bd9Sstevel@tonic-gate /* get the encode and decode size */ 29047c478bd9Sstevel@tonic-gate if (!xdr_int(xdr, &encode_len) || !xdr_int(xdr, &decode_len)) 29057c478bd9Sstevel@tonic-gate return (EFAULT); 29067c478bd9Sstevel@tonic-gate *size = decode_len; 29077c478bd9Sstevel@tonic-gate 29087c478bd9Sstevel@tonic-gate /* are we at the end of the stream? */ 29097c478bd9Sstevel@tonic-gate if (*size == 0) 29107c478bd9Sstevel@tonic-gate return (0); 29117c478bd9Sstevel@tonic-gate 29127c478bd9Sstevel@tonic-gate /* sanity check the size parameter */ 29137c478bd9Sstevel@tonic-gate if (!xdr_control(xdr, XDR_GET_BYTES_AVAIL, &bytesrec)) 29147c478bd9Sstevel@tonic-gate return (EFAULT); 29157c478bd9Sstevel@tonic-gate 29167c478bd9Sstevel@tonic-gate if (*size > NVS_XDR_MAX_LEN(bytesrec.xc_num_avail)) 29177c478bd9Sstevel@tonic-gate return (EFAULT); 29187c478bd9Sstevel@tonic-gate break; 29197c478bd9Sstevel@tonic-gate } 29207c478bd9Sstevel@tonic-gate 29217c478bd9Sstevel@tonic-gate default: 29227c478bd9Sstevel@tonic-gate return (EINVAL); 29237c478bd9Sstevel@tonic-gate } 29247c478bd9Sstevel@tonic-gate return (0); 29257c478bd9Sstevel@tonic-gate } 29267c478bd9Sstevel@tonic-gate 29277c478bd9Sstevel@tonic-gate static const struct nvs_ops nvs_xdr_ops = { 29287c478bd9Sstevel@tonic-gate nvs_xdr_nvlist, 29297c478bd9Sstevel@tonic-gate nvs_xdr_nvpair, 29307c478bd9Sstevel@tonic-gate nvs_xdr_nvp_op, 29317c478bd9Sstevel@tonic-gate nvs_xdr_nvp_size, 29327c478bd9Sstevel@tonic-gate nvs_xdr_nvl_fini 29337c478bd9Sstevel@tonic-gate }; 29347c478bd9Sstevel@tonic-gate 29357c478bd9Sstevel@tonic-gate static int 29367c478bd9Sstevel@tonic-gate nvs_xdr(nvstream_t *nvs, nvlist_t *nvl, char *buf, size_t *buflen) 29377c478bd9Sstevel@tonic-gate { 29387c478bd9Sstevel@tonic-gate XDR xdr; 29397c478bd9Sstevel@tonic-gate int err; 29407c478bd9Sstevel@tonic-gate 29417c478bd9Sstevel@tonic-gate nvs->nvs_ops = &nvs_xdr_ops; 29427c478bd9Sstevel@tonic-gate 29437c478bd9Sstevel@tonic-gate if ((err = nvs_xdr_create(nvs, &xdr, buf + sizeof (nvs_header_t), 29447c478bd9Sstevel@tonic-gate *buflen - sizeof (nvs_header_t))) != 0) 29457c478bd9Sstevel@tonic-gate return (err); 29467c478bd9Sstevel@tonic-gate 29477c478bd9Sstevel@tonic-gate err = nvs_operation(nvs, nvl, buflen); 29487c478bd9Sstevel@tonic-gate 29497c478bd9Sstevel@tonic-gate nvs_xdr_destroy(nvs); 29507c478bd9Sstevel@tonic-gate 29517c478bd9Sstevel@tonic-gate return (err); 29527c478bd9Sstevel@tonic-gate } 2953