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) 2012, 2018 by Delphix. All rights reserved. 24 */ 25 26 #include <sys/nvpair.h> 27 #include <sys/kmem.h> 28 #include <sys/debug.h> 29 #include <sys/param.h> 30 #ifndef _KERNEL 31 #include <stdlib.h> 32 #endif 33 34 /* 35 * "Force" nvlist wrapper. 36 * 37 * These functions wrap the nvlist_* functions with assertions that assume 38 * the operation is successful. This allows the caller's code to be much 39 * more readable, especially for the fnvlist_lookup_* and fnvpair_value_* 40 * functions, which can return the requested value (rather than filling in 41 * a pointer). 42 * 43 * These functions use NV_UNIQUE_NAME, encoding NV_ENCODE_NATIVE, and allocate 44 * with KM_SLEEP. 45 * 46 * More wrappers should be added as needed -- for example 47 * nvlist_lookup_*_array and nvpair_value_*_array. 48 */ 49 50 nvlist_t * 51 fnvlist_alloc(void) 52 { 53 nvlist_t *nvl; 54 VERIFY0(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP)); 55 return (nvl); 56 } 57 58 void 59 fnvlist_free(nvlist_t *nvl) 60 { 61 nvlist_free(nvl); 62 } 63 64 size_t 65 fnvlist_size(nvlist_t *nvl) 66 { 67 size_t size; 68 VERIFY0(nvlist_size(nvl, &size, NV_ENCODE_NATIVE)); 69 return (size); 70 } 71 72 /* 73 * Returns allocated buffer of size *sizep. Caller must free the buffer with 74 * fnvlist_pack_free(). 75 */ 76 char * 77 fnvlist_pack(nvlist_t *nvl, size_t *sizep) 78 { 79 char *packed = 0; 80 VERIFY3U(nvlist_pack(nvl, &packed, sizep, NV_ENCODE_NATIVE, 81 KM_SLEEP), ==, 0); 82 return (packed); 83 } 84 85 /*ARGSUSED*/ 86 void 87 fnvlist_pack_free(char *pack, size_t size) 88 { 89 #ifdef _KERNEL 90 kmem_free(pack, size); 91 #else 92 free(pack); 93 #endif 94 } 95 96 nvlist_t * 97 fnvlist_unpack(char *buf, size_t buflen) 98 { 99 nvlist_t *rv; 100 VERIFY0(nvlist_unpack(buf, buflen, &rv, KM_SLEEP)); 101 return (rv); 102 } 103 104 nvlist_t * 105 fnvlist_dup(nvlist_t *nvl) 106 { 107 nvlist_t *rv; 108 VERIFY0(nvlist_dup(nvl, &rv, KM_SLEEP)); 109 return (rv); 110 } 111 112 void 113 fnvlist_merge(nvlist_t *dst, nvlist_t *src) 114 { 115 VERIFY0(nvlist_merge(dst, src, KM_SLEEP)); 116 } 117 118 size_t 119 fnvlist_num_pairs(nvlist_t *nvl) 120 { 121 size_t count = 0; 122 nvpair_t *pair; 123 124 for (pair = nvlist_next_nvpair(nvl, 0); pair != NULL; 125 pair = nvlist_next_nvpair(nvl, pair)) 126 count++; 127 return (count); 128 } 129 130 void 131 fnvlist_add_boolean(nvlist_t *nvl, const char *name) 132 { 133 VERIFY0(nvlist_add_boolean(nvl, name)); 134 } 135 136 void 137 fnvlist_add_boolean_value(nvlist_t *nvl, const char *name, boolean_t val) 138 { 139 VERIFY0(nvlist_add_boolean_value(nvl, name, val)); 140 } 141 142 void 143 fnvlist_add_byte(nvlist_t *nvl, const char *name, uchar_t val) 144 { 145 VERIFY0(nvlist_add_byte(nvl, name, val)); 146 } 147 148 void 149 fnvlist_add_int8(nvlist_t *nvl, const char *name, int8_t val) 150 { 151 VERIFY0(nvlist_add_int8(nvl, name, val)); 152 } 153 154 void 155 fnvlist_add_uint8(nvlist_t *nvl, const char *name, uint8_t val) 156 { 157 VERIFY0(nvlist_add_uint8(nvl, name, val)); 158 } 159 160 void 161 fnvlist_add_int16(nvlist_t *nvl, const char *name, int16_t val) 162 { 163 VERIFY0(nvlist_add_int16(nvl, name, val)); 164 } 165 166 void 167 fnvlist_add_uint16(nvlist_t *nvl, const char *name, uint16_t val) 168 { 169 VERIFY0(nvlist_add_uint16(nvl, name, val)); 170 } 171 172 void 173 fnvlist_add_int32(nvlist_t *nvl, const char *name, int32_t val) 174 { 175 VERIFY0(nvlist_add_int32(nvl, name, val)); 176 } 177 178 void 179 fnvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val) 180 { 181 VERIFY0(nvlist_add_uint32(nvl, name, val)); 182 } 183 184 void 185 fnvlist_add_int64(nvlist_t *nvl, const char *name, int64_t val) 186 { 187 VERIFY0(nvlist_add_int64(nvl, name, val)); 188 } 189 190 void 191 fnvlist_add_uint64(nvlist_t *nvl, const char *name, uint64_t val) 192 { 193 VERIFY0(nvlist_add_uint64(nvl, name, val)); 194 } 195 196 void 197 fnvlist_add_string(nvlist_t *nvl, const char *name, const char *val) 198 { 199 VERIFY0(nvlist_add_string(nvl, name, val)); 200 } 201 202 void 203 fnvlist_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val) 204 { 205 VERIFY0(nvlist_add_nvlist(nvl, name, val)); 206 } 207 208 void 209 fnvlist_add_nvpair(nvlist_t *nvl, nvpair_t *pair) 210 { 211 VERIFY0(nvlist_add_nvpair(nvl, pair)); 212 } 213 214 void 215 fnvlist_add_boolean_array(nvlist_t *nvl, const char *name, 216 boolean_t *val, uint_t n) 217 { 218 VERIFY0(nvlist_add_boolean_array(nvl, name, val, n)); 219 } 220 221 void 222 fnvlist_add_byte_array(nvlist_t *nvl, const char *name, uchar_t *val, uint_t n) 223 { 224 VERIFY0(nvlist_add_byte_array(nvl, name, val, n)); 225 } 226 227 void 228 fnvlist_add_int8_array(nvlist_t *nvl, const char *name, int8_t *val, uint_t n) 229 { 230 VERIFY0(nvlist_add_int8_array(nvl, name, val, n)); 231 } 232 233 void 234 fnvlist_add_uint8_array(nvlist_t *nvl, const char *name, uint8_t *val, uint_t n) 235 { 236 VERIFY0(nvlist_add_uint8_array(nvl, name, val, n)); 237 } 238 239 void 240 fnvlist_add_int16_array(nvlist_t *nvl, const char *name, int16_t *val, uint_t n) 241 { 242 VERIFY0(nvlist_add_int16_array(nvl, name, val, n)); 243 } 244 245 void 246 fnvlist_add_uint16_array(nvlist_t *nvl, const char *name, 247 uint16_t *val, uint_t n) 248 { 249 VERIFY0(nvlist_add_uint16_array(nvl, name, val, n)); 250 } 251 252 void 253 fnvlist_add_int32_array(nvlist_t *nvl, const char *name, int32_t *val, uint_t n) 254 { 255 VERIFY0(nvlist_add_int32_array(nvl, name, val, n)); 256 } 257 258 void 259 fnvlist_add_uint32_array(nvlist_t *nvl, const char *name, 260 uint32_t *val, uint_t n) 261 { 262 VERIFY0(nvlist_add_uint32_array(nvl, name, val, n)); 263 } 264 265 void 266 fnvlist_add_int64_array(nvlist_t *nvl, const char *name, int64_t *val, uint_t n) 267 { 268 VERIFY0(nvlist_add_int64_array(nvl, name, val, n)); 269 } 270 271 void 272 fnvlist_add_uint64_array(nvlist_t *nvl, const char *name, 273 uint64_t *val, uint_t n) 274 { 275 VERIFY0(nvlist_add_uint64_array(nvl, name, val, n)); 276 } 277 278 void 279 fnvlist_add_string_array(nvlist_t *nvl, const char *name, 280 char * const *val, uint_t n) 281 { 282 VERIFY0(nvlist_add_string_array(nvl, name, val, n)); 283 } 284 285 void 286 fnvlist_add_nvlist_array(nvlist_t *nvl, const char *name, 287 nvlist_t **val, uint_t n) 288 { 289 VERIFY0(nvlist_add_nvlist_array(nvl, name, val, n)); 290 } 291 292 void 293 fnvlist_remove(nvlist_t *nvl, const char *name) 294 { 295 VERIFY0(nvlist_remove_all(nvl, name)); 296 } 297 298 void 299 fnvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *pair) 300 { 301 VERIFY0(nvlist_remove_nvpair(nvl, pair)); 302 } 303 304 nvpair_t * 305 fnvlist_lookup_nvpair(nvlist_t *nvl, const char *name) 306 { 307 nvpair_t *rv; 308 VERIFY0(nvlist_lookup_nvpair(nvl, name, &rv)); 309 return (rv); 310 } 311 312 /* returns B_TRUE if the entry exists */ 313 boolean_t 314 fnvlist_lookup_boolean(nvlist_t *nvl, const char *name) 315 { 316 return (nvlist_lookup_boolean(nvl, name) == 0); 317 } 318 319 boolean_t 320 fnvlist_lookup_boolean_value(nvlist_t *nvl, const char *name) 321 { 322 boolean_t rv; 323 VERIFY0(nvlist_lookup_boolean_value(nvl, name, &rv)); 324 return (rv); 325 } 326 327 uchar_t 328 fnvlist_lookup_byte(nvlist_t *nvl, const char *name) 329 { 330 uchar_t rv; 331 VERIFY0(nvlist_lookup_byte(nvl, name, &rv)); 332 return (rv); 333 } 334 335 int8_t 336 fnvlist_lookup_int8(nvlist_t *nvl, const char *name) 337 { 338 int8_t rv; 339 VERIFY0(nvlist_lookup_int8(nvl, name, &rv)); 340 return (rv); 341 } 342 343 int16_t 344 fnvlist_lookup_int16(nvlist_t *nvl, const char *name) 345 { 346 int16_t rv; 347 VERIFY0(nvlist_lookup_int16(nvl, name, &rv)); 348 return (rv); 349 } 350 351 int32_t 352 fnvlist_lookup_int32(nvlist_t *nvl, const char *name) 353 { 354 int32_t rv; 355 VERIFY0(nvlist_lookup_int32(nvl, name, &rv)); 356 return (rv); 357 } 358 359 int64_t 360 fnvlist_lookup_int64(nvlist_t *nvl, const char *name) 361 { 362 int64_t rv; 363 VERIFY0(nvlist_lookup_int64(nvl, name, &rv)); 364 return (rv); 365 } 366 367 uint8_t 368 fnvlist_lookup_uint8(nvlist_t *nvl, const char *name) 369 { 370 uint8_t rv; 371 VERIFY0(nvlist_lookup_uint8(nvl, name, &rv)); 372 return (rv); 373 } 374 375 uint16_t 376 fnvlist_lookup_uint16(nvlist_t *nvl, const char *name) 377 { 378 uint16_t rv; 379 VERIFY0(nvlist_lookup_uint16(nvl, name, &rv)); 380 return (rv); 381 } 382 383 uint32_t 384 fnvlist_lookup_uint32(nvlist_t *nvl, const char *name) 385 { 386 uint32_t rv; 387 VERIFY0(nvlist_lookup_uint32(nvl, name, &rv)); 388 return (rv); 389 } 390 391 uint64_t 392 fnvlist_lookup_uint64(nvlist_t *nvl, const char *name) 393 { 394 uint64_t rv; 395 VERIFY0(nvlist_lookup_uint64(nvl, name, &rv)); 396 return (rv); 397 } 398 399 char * 400 fnvlist_lookup_string(nvlist_t *nvl, const char *name) 401 { 402 char *rv; 403 VERIFY0(nvlist_lookup_string(nvl, name, &rv)); 404 return (rv); 405 } 406 407 nvlist_t * 408 fnvlist_lookup_nvlist(nvlist_t *nvl, const char *name) 409 { 410 nvlist_t *rv; 411 VERIFY0(nvlist_lookup_nvlist(nvl, name, &rv)); 412 return (rv); 413 } 414 boolean_t * 415 fnvlist_lookup_boolean_array(nvlist_t *nvl, const char *name, uint_t *n) 416 { 417 boolean_t *rv; 418 VERIFY0(nvlist_lookup_boolean_array(nvl, name, &rv, n)); 419 return (rv); 420 } 421 422 uchar_t * 423 fnvlist_lookup_byte_array(nvlist_t *nvl, const char *name, uint_t *n) 424 { 425 uchar_t *rv; 426 VERIFY0(nvlist_lookup_byte_array(nvl, name, &rv, n)); 427 return (rv); 428 } 429 430 int8_t * 431 fnvlist_lookup_int8_array(nvlist_t *nvl, const char *name, uint_t *n) 432 { 433 int8_t *rv; 434 VERIFY0(nvlist_lookup_int8_array(nvl, name, &rv, n)); 435 return (rv); 436 } 437 438 uint8_t * 439 fnvlist_lookup_uint8_array(nvlist_t *nvl, const char *name, uint_t *n) 440 { 441 uint8_t *rv; 442 VERIFY0(nvlist_lookup_uint8_array(nvl, name, &rv, n)); 443 return (rv); 444 } 445 446 int16_t * 447 fnvlist_lookup_int16_array(nvlist_t *nvl, const char *name, uint_t *n) 448 { 449 int16_t *rv; 450 VERIFY0(nvlist_lookup_int16_array(nvl, name, &rv, n)); 451 return (rv); 452 } 453 454 uint16_t * 455 fnvlist_lookup_uint16_array(nvlist_t *nvl, const char *name, uint_t *n) 456 { 457 uint16_t *rv; 458 VERIFY0(nvlist_lookup_uint16_array(nvl, name, &rv, n)); 459 return (rv); 460 } 461 462 int32_t * 463 fnvlist_lookup_int32_array(nvlist_t *nvl, const char *name, uint_t *n) 464 { 465 int32_t *rv; 466 VERIFY0(nvlist_lookup_int32_array(nvl, name, &rv, n)); 467 return (rv); 468 } 469 470 uint32_t * 471 fnvlist_lookup_uint32_array(nvlist_t *nvl, const char *name, uint_t *n) 472 { 473 uint32_t *rv; 474 VERIFY0(nvlist_lookup_uint32_array(nvl, name, &rv, n)); 475 return (rv); 476 } 477 478 int64_t * 479 fnvlist_lookup_int64_array(nvlist_t *nvl, const char *name, uint_t *n) 480 { 481 int64_t *rv; 482 VERIFY0(nvlist_lookup_int64_array(nvl, name, &rv, n)); 483 return (rv); 484 } 485 486 uint64_t * 487 fnvlist_lookup_uint64_array(nvlist_t *nvl, const char *name, uint_t *n) 488 { 489 uint64_t *rv; 490 VERIFY0(nvlist_lookup_uint64_array(nvl, name, &rv, n)); 491 return (rv); 492 } 493 494 boolean_t 495 fnvpair_value_boolean_value(nvpair_t *nvp) 496 { 497 boolean_t rv; 498 VERIFY0(nvpair_value_boolean_value(nvp, &rv)); 499 return (rv); 500 } 501 502 uchar_t 503 fnvpair_value_byte(nvpair_t *nvp) 504 { 505 uchar_t rv; 506 VERIFY0(nvpair_value_byte(nvp, &rv)); 507 return (rv); 508 } 509 510 int8_t 511 fnvpair_value_int8(nvpair_t *nvp) 512 { 513 int8_t rv; 514 VERIFY0(nvpair_value_int8(nvp, &rv)); 515 return (rv); 516 } 517 518 int16_t 519 fnvpair_value_int16(nvpair_t *nvp) 520 { 521 int16_t rv; 522 VERIFY0(nvpair_value_int16(nvp, &rv)); 523 return (rv); 524 } 525 526 int32_t 527 fnvpair_value_int32(nvpair_t *nvp) 528 { 529 int32_t rv; 530 VERIFY0(nvpair_value_int32(nvp, &rv)); 531 return (rv); 532 } 533 534 int64_t 535 fnvpair_value_int64(nvpair_t *nvp) 536 { 537 int64_t rv; 538 VERIFY0(nvpair_value_int64(nvp, &rv)); 539 return (rv); 540 } 541 542 uint8_t 543 fnvpair_value_uint8(nvpair_t *nvp) 544 { 545 uint8_t rv; 546 VERIFY0(nvpair_value_uint8(nvp, &rv)); 547 return (rv); 548 } 549 550 uint16_t 551 fnvpair_value_uint16(nvpair_t *nvp) 552 { 553 uint16_t rv; 554 VERIFY0(nvpair_value_uint16(nvp, &rv)); 555 return (rv); 556 } 557 558 uint32_t 559 fnvpair_value_uint32(nvpair_t *nvp) 560 { 561 uint32_t rv; 562 VERIFY0(nvpair_value_uint32(nvp, &rv)); 563 return (rv); 564 } 565 566 uint64_t 567 fnvpair_value_uint64(nvpair_t *nvp) 568 { 569 uint64_t rv; 570 VERIFY0(nvpair_value_uint64(nvp, &rv)); 571 return (rv); 572 } 573 574 char * 575 fnvpair_value_string(nvpair_t *nvp) 576 { 577 char *rv; 578 VERIFY0(nvpair_value_string(nvp, &rv)); 579 return (rv); 580 } 581 582 nvlist_t * 583 fnvpair_value_nvlist(nvpair_t *nvp) 584 { 585 nvlist_t *rv; 586 VERIFY0(nvpair_value_nvlist(nvp, &rv)); 587 return (rv); 588 } 589 590 #if defined(_KERNEL) 591 592 EXPORT_SYMBOL(fnvlist_alloc); 593 EXPORT_SYMBOL(fnvlist_free); 594 EXPORT_SYMBOL(fnvlist_size); 595 EXPORT_SYMBOL(fnvlist_pack); 596 EXPORT_SYMBOL(fnvlist_pack_free); 597 EXPORT_SYMBOL(fnvlist_unpack); 598 EXPORT_SYMBOL(fnvlist_dup); 599 EXPORT_SYMBOL(fnvlist_merge); 600 601 EXPORT_SYMBOL(fnvlist_add_nvpair); 602 EXPORT_SYMBOL(fnvlist_add_boolean); 603 EXPORT_SYMBOL(fnvlist_add_boolean_value); 604 EXPORT_SYMBOL(fnvlist_add_byte); 605 EXPORT_SYMBOL(fnvlist_add_int8); 606 EXPORT_SYMBOL(fnvlist_add_uint8); 607 EXPORT_SYMBOL(fnvlist_add_int16); 608 EXPORT_SYMBOL(fnvlist_add_uint16); 609 EXPORT_SYMBOL(fnvlist_add_int32); 610 EXPORT_SYMBOL(fnvlist_add_uint32); 611 EXPORT_SYMBOL(fnvlist_add_int64); 612 EXPORT_SYMBOL(fnvlist_add_uint64); 613 EXPORT_SYMBOL(fnvlist_add_string); 614 EXPORT_SYMBOL(fnvlist_add_nvlist); 615 EXPORT_SYMBOL(fnvlist_add_boolean_array); 616 EXPORT_SYMBOL(fnvlist_add_byte_array); 617 EXPORT_SYMBOL(fnvlist_add_int8_array); 618 EXPORT_SYMBOL(fnvlist_add_uint8_array); 619 EXPORT_SYMBOL(fnvlist_add_int16_array); 620 EXPORT_SYMBOL(fnvlist_add_uint16_array); 621 EXPORT_SYMBOL(fnvlist_add_int32_array); 622 EXPORT_SYMBOL(fnvlist_add_uint32_array); 623 EXPORT_SYMBOL(fnvlist_add_int64_array); 624 EXPORT_SYMBOL(fnvlist_add_uint64_array); 625 EXPORT_SYMBOL(fnvlist_add_string_array); 626 EXPORT_SYMBOL(fnvlist_add_nvlist_array); 627 628 EXPORT_SYMBOL(fnvlist_remove); 629 EXPORT_SYMBOL(fnvlist_remove_nvpair); 630 631 EXPORT_SYMBOL(fnvlist_lookup_nvpair); 632 EXPORT_SYMBOL(fnvlist_lookup_boolean); 633 EXPORT_SYMBOL(fnvlist_lookup_boolean_value); 634 EXPORT_SYMBOL(fnvlist_lookup_byte); 635 EXPORT_SYMBOL(fnvlist_lookup_int8); 636 EXPORT_SYMBOL(fnvlist_lookup_uint8); 637 EXPORT_SYMBOL(fnvlist_lookup_int16); 638 EXPORT_SYMBOL(fnvlist_lookup_uint16); 639 EXPORT_SYMBOL(fnvlist_lookup_int32); 640 EXPORT_SYMBOL(fnvlist_lookup_uint32); 641 EXPORT_SYMBOL(fnvlist_lookup_int64); 642 EXPORT_SYMBOL(fnvlist_lookup_uint64); 643 EXPORT_SYMBOL(fnvlist_lookup_string); 644 EXPORT_SYMBOL(fnvlist_lookup_nvlist); 645 646 EXPORT_SYMBOL(fnvpair_value_boolean_value); 647 EXPORT_SYMBOL(fnvpair_value_byte); 648 EXPORT_SYMBOL(fnvpair_value_int8); 649 EXPORT_SYMBOL(fnvpair_value_uint8); 650 EXPORT_SYMBOL(fnvpair_value_int16); 651 EXPORT_SYMBOL(fnvpair_value_uint16); 652 EXPORT_SYMBOL(fnvpair_value_int32); 653 EXPORT_SYMBOL(fnvpair_value_uint32); 654 EXPORT_SYMBOL(fnvpair_value_int64); 655 EXPORT_SYMBOL(fnvpair_value_uint64); 656 EXPORT_SYMBOL(fnvpair_value_string); 657 EXPORT_SYMBOL(fnvpair_value_nvlist); 658 EXPORT_SYMBOL(fnvlist_num_pairs); 659 660 #endif 661