module/nvpair/fnvpair.c

   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