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