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