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 50nvlist_t * 51fnvlist_alloc(void) 52{ 53 nvlist_t *nvl; 54 VERIFY0(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP)); 55 return (nvl); 56} 57 58void 59fnvlist_free(nvlist_t *nvl) 60{ 61 nvlist_free(nvl); 62} 63 64size_t 65fnvlist_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 */ 76char * 77fnvlist_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*/ 86void 87fnvlist_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 96nvlist_t * 97fnvlist_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 104nvlist_t * 105fnvlist_dup(nvlist_t *nvl) 106{ 107 nvlist_t *rv; 108 VERIFY0(nvlist_dup(nvl, &rv, KM_SLEEP)); 109 return (rv); 110} 111 112void 113fnvlist_merge(nvlist_t *dst, nvlist_t *src) 114{ 115 VERIFY0(nvlist_merge(dst, src, KM_SLEEP)); 116} 117 118size_t 119fnvlist_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 130void 131fnvlist_add_boolean(nvlist_t *nvl, const char *name) 132{ 133 VERIFY0(nvlist_add_boolean(nvl, name)); 134} 135 136void 137fnvlist_add_boolean_value(nvlist_t *nvl, const char *name, boolean_t val) 138{ 139 VERIFY0(nvlist_add_boolean_value(nvl, name, val)); 140} 141 142void 143fnvlist_add_byte(nvlist_t *nvl, const char *name, uchar_t val) 144{ 145 VERIFY0(nvlist_add_byte(nvl, name, val)); 146} 147 148void 149fnvlist_add_int8(nvlist_t *nvl, const char *name, int8_t val) 150{ 151 VERIFY0(nvlist_add_int8(nvl, name, val)); 152} 153 154void 155fnvlist_add_uint8(nvlist_t *nvl, const char *name, uint8_t val) 156{ 157 VERIFY0(nvlist_add_uint8(nvl, name, val)); 158} 159 160void 161fnvlist_add_int16(nvlist_t *nvl, const char *name, int16_t val) 162{ 163 VERIFY0(nvlist_add_int16(nvl, name, val)); 164} 165 166void 167fnvlist_add_uint16(nvlist_t *nvl, const char *name, uint16_t val) 168{ 169 VERIFY0(nvlist_add_uint16(nvl, name, val)); 170} 171 172void 173fnvlist_add_int32(nvlist_t *nvl, const char *name, int32_t val) 174{ 175 VERIFY0(nvlist_add_int32(nvl, name, val)); 176} 177 178void 179fnvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val) 180{ 181 VERIFY0(nvlist_add_uint32(nvl, name, val)); 182} 183 184void 185fnvlist_add_int64(nvlist_t *nvl, const char *name, int64_t val) 186{ 187 VERIFY0(nvlist_add_int64(nvl, name, val)); 188} 189 190void 191fnvlist_add_uint64(nvlist_t *nvl, const char *name, uint64_t val) 192{ 193 VERIFY0(nvlist_add_uint64(nvl, name, val)); 194} 195 196void 197fnvlist_add_string(nvlist_t *nvl, const char *name, const char *val) 198{ 199 VERIFY0(nvlist_add_string(nvl, name, val)); 200} 201 202void 203fnvlist_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val) 204{ 205 VERIFY0(nvlist_add_nvlist(nvl, name, val)); 206} 207 208void 209fnvlist_add_nvpair(nvlist_t *nvl, nvpair_t *pair) 210{ 211 VERIFY0(nvlist_add_nvpair(nvl, pair)); 212} 213 214void 215fnvlist_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 221void 222fnvlist_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 227void 228fnvlist_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 233void 234fnvlist_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 239void 240fnvlist_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 245void 246fnvlist_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 252void 253fnvlist_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 258void 259fnvlist_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 265void 266fnvlist_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 271void 272fnvlist_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 278void 279fnvlist_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 285void 286fnvlist_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 292void 293fnvlist_remove(nvlist_t *nvl, const char *name) 294{ 295 VERIFY0(nvlist_remove_all(nvl, name)); 296} 297 298void 299fnvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *pair) 300{ 301 VERIFY0(nvlist_remove_nvpair(nvl, pair)); 302} 303 304nvpair_t * 305fnvlist_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 */ 313boolean_t 314fnvlist_lookup_boolean(nvlist_t *nvl, const char *name) 315{ 316 return (nvlist_lookup_boolean(nvl, name) == 0); 317} 318 319boolean_t 320fnvlist_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 327uchar_t 328fnvlist_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 335int8_t 336fnvlist_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 343int16_t 344fnvlist_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 351int32_t 352fnvlist_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 359int64_t 360fnvlist_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 367uint8_t 368fnvlist_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 375uint16_t 376fnvlist_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 383uint32_t 384fnvlist_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 391uint64_t 392fnvlist_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 399char * 400fnvlist_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 407nvlist_t * 408fnvlist_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} 414boolean_t * 415fnvlist_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 422uchar_t * 423fnvlist_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 430int8_t * 431fnvlist_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 438uint8_t * 439fnvlist_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 446int16_t * 447fnvlist_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 454uint16_t * 455fnvlist_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 462int32_t * 463fnvlist_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 470uint32_t * 471fnvlist_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 478int64_t * 479fnvlist_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 486uint64_t * 487fnvlist_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 494boolean_t 495fnvpair_value_boolean_value(nvpair_t *nvp) 496{ 497 boolean_t rv; 498 VERIFY0(nvpair_value_boolean_value(nvp, &rv)); 499 return (rv); 500} 501 502uchar_t 503fnvpair_value_byte(nvpair_t *nvp) 504{ 505 uchar_t rv; 506 VERIFY0(nvpair_value_byte(nvp, &rv)); 507 return (rv); 508} 509 510int8_t 511fnvpair_value_int8(nvpair_t *nvp) 512{ 513 int8_t rv; 514 VERIFY0(nvpair_value_int8(nvp, &rv)); 515 return (rv); 516} 517 518int16_t 519fnvpair_value_int16(nvpair_t *nvp) 520{ 521 int16_t rv; 522 VERIFY0(nvpair_value_int16(nvp, &rv)); 523 return (rv); 524} 525 526int32_t 527fnvpair_value_int32(nvpair_t *nvp) 528{ 529 int32_t rv; 530 VERIFY0(nvpair_value_int32(nvp, &rv)); 531 return (rv); 532} 533 534int64_t 535fnvpair_value_int64(nvpair_t *nvp) 536{ 537 int64_t rv; 538 VERIFY0(nvpair_value_int64(nvp, &rv)); 539 return (rv); 540} 541 542uint8_t 543fnvpair_value_uint8(nvpair_t *nvp) 544{ 545 uint8_t rv; 546 VERIFY0(nvpair_value_uint8(nvp, &rv)); 547 return (rv); 548} 549 550uint16_t 551fnvpair_value_uint16(nvpair_t *nvp) 552{ 553 uint16_t rv; 554 VERIFY0(nvpair_value_uint16(nvp, &rv)); 555 return (rv); 556} 557 558uint32_t 559fnvpair_value_uint32(nvpair_t *nvp) 560{ 561 uint32_t rv; 562 VERIFY0(nvpair_value_uint32(nvp, &rv)); 563 return (rv); 564} 565 566uint64_t 567fnvpair_value_uint64(nvpair_t *nvp) 568{ 569 uint64_t rv; 570 VERIFY0(nvpair_value_uint64(nvp, &rv)); 571 return (rv); 572} 573 574char * 575fnvpair_value_string(nvpair_t *nvp) 576{ 577 char *rv; 578 VERIFY0(nvpair_value_string(nvp, &rv)); 579 return (rv); 580} 581 582nvlist_t * 583fnvpair_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 592EXPORT_SYMBOL(fnvlist_alloc); 593EXPORT_SYMBOL(fnvlist_free); 594EXPORT_SYMBOL(fnvlist_size); 595EXPORT_SYMBOL(fnvlist_pack); 596EXPORT_SYMBOL(fnvlist_pack_free); 597EXPORT_SYMBOL(fnvlist_unpack); 598EXPORT_SYMBOL(fnvlist_dup); 599EXPORT_SYMBOL(fnvlist_merge); 600 601EXPORT_SYMBOL(fnvlist_add_nvpair); 602EXPORT_SYMBOL(fnvlist_add_boolean); 603EXPORT_SYMBOL(fnvlist_add_boolean_value); 604EXPORT_SYMBOL(fnvlist_add_byte); 605EXPORT_SYMBOL(fnvlist_add_int8); 606EXPORT_SYMBOL(fnvlist_add_uint8); 607EXPORT_SYMBOL(fnvlist_add_int16); 608EXPORT_SYMBOL(fnvlist_add_uint16); 609EXPORT_SYMBOL(fnvlist_add_int32); 610EXPORT_SYMBOL(fnvlist_add_uint32); 611EXPORT_SYMBOL(fnvlist_add_int64); 612EXPORT_SYMBOL(fnvlist_add_uint64); 613EXPORT_SYMBOL(fnvlist_add_string); 614EXPORT_SYMBOL(fnvlist_add_nvlist); 615EXPORT_SYMBOL(fnvlist_add_boolean_array); 616EXPORT_SYMBOL(fnvlist_add_byte_array); 617EXPORT_SYMBOL(fnvlist_add_int8_array); 618EXPORT_SYMBOL(fnvlist_add_uint8_array); 619EXPORT_SYMBOL(fnvlist_add_int16_array); 620EXPORT_SYMBOL(fnvlist_add_uint16_array); 621EXPORT_SYMBOL(fnvlist_add_int32_array); 622EXPORT_SYMBOL(fnvlist_add_uint32_array); 623EXPORT_SYMBOL(fnvlist_add_int64_array); 624EXPORT_SYMBOL(fnvlist_add_uint64_array); 625EXPORT_SYMBOL(fnvlist_add_string_array); 626EXPORT_SYMBOL(fnvlist_add_nvlist_array); 627 628EXPORT_SYMBOL(fnvlist_remove); 629EXPORT_SYMBOL(fnvlist_remove_nvpair); 630 631EXPORT_SYMBOL(fnvlist_lookup_nvpair); 632EXPORT_SYMBOL(fnvlist_lookup_boolean); 633EXPORT_SYMBOL(fnvlist_lookup_boolean_value); 634EXPORT_SYMBOL(fnvlist_lookup_byte); 635EXPORT_SYMBOL(fnvlist_lookup_int8); 636EXPORT_SYMBOL(fnvlist_lookup_uint8); 637EXPORT_SYMBOL(fnvlist_lookup_int16); 638EXPORT_SYMBOL(fnvlist_lookup_uint16); 639EXPORT_SYMBOL(fnvlist_lookup_int32); 640EXPORT_SYMBOL(fnvlist_lookup_uint32); 641EXPORT_SYMBOL(fnvlist_lookup_int64); 642EXPORT_SYMBOL(fnvlist_lookup_uint64); 643EXPORT_SYMBOL(fnvlist_lookup_string); 644EXPORT_SYMBOL(fnvlist_lookup_nvlist); 645 646EXPORT_SYMBOL(fnvpair_value_boolean_value); 647EXPORT_SYMBOL(fnvpair_value_byte); 648EXPORT_SYMBOL(fnvpair_value_int8); 649EXPORT_SYMBOL(fnvpair_value_uint8); 650EXPORT_SYMBOL(fnvpair_value_int16); 651EXPORT_SYMBOL(fnvpair_value_uint16); 652EXPORT_SYMBOL(fnvpair_value_int32); 653EXPORT_SYMBOL(fnvpair_value_uint32); 654EXPORT_SYMBOL(fnvpair_value_int64); 655EXPORT_SYMBOL(fnvpair_value_uint64); 656EXPORT_SYMBOL(fnvpair_value_string); 657EXPORT_SYMBOL(fnvpair_value_nvlist); 658EXPORT_SYMBOL(fnvlist_num_pairs); 659 660#endif 661