sys/cddl/contrib/opensolaris/common/nvpair/fnvpair.c

   1
   2 /*
   3  * CDDL HEADER START
   4  *
   5  * The contents of this file are subject to the terms of the
   6  * Common Development and Distribution License (the "License").
   7  * You may not use this file except in compliance with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22
  23 /*
  24  * Copyright (c) 2012 by Delphix. All rights reserved.
  25  */
  26
  27 #include <sys/nvpair.h>
  28 #ifndef _KERNEL
  29 #include <sys/zfs_context.h>
  30 #else
  31 #include <sys/debug.h>
  32 #include <sys/kmem.h>
  33 #include <sys/param.h>
  34 #include <sys/debug.h>
  35 #endif
  36
  37 /*
  38  * "Force" nvlist wrapper.
  39  *
  40  * These functions wrap the nvlist_* functions with assertions that assume
  41  * the operation is successful.  This allows the caller's code to be much
  42  * more readable, especially for the fnvlist_lookup_* and fnvpair_value_*
  43  * functions, which can return the requested value (rather than filling in
  44  * a pointer).
  45  *
  46  * These functions use NV_UNIQUE_NAME, encoding NV_ENCODE_NATIVE, and allocate
  47  * with KM_SLEEP.
  48  *
  49  * More wrappers should be added as needed -- for example
  50  * nvlist_lookup_*_array and nvpair_value_*_array.
  51  */
  52
  53 nvlist_t *
  54 fnvlist_alloc(void)
  55 {
  56         nvlist_t *nvl;
  57         VERIFY0(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP));
  58         return (nvl);
  59 }
  60
  61 void
  62 fnvlist_free(nvlist_t *nvl)
  63 {
  64         nvlist_free(nvl);
  65 }
  66
  67 size_t
  68 fnvlist_size(nvlist_t *nvl)
  69 {
  70         size_t size;
  71         VERIFY0(nvlist_size(nvl, &size, NV_ENCODE_NATIVE));
  72         return (size);
  73 }
  74
  75 /*
  76  * Returns allocated buffer of size *sizep.  Caller must free the buffer with
  77  * fnvlist_pack_free().
  78  */
  79 char *
  80 fnvlist_pack(nvlist_t *nvl, size_t *sizep)
  81 {
  82         char *packed = 0;
  83         VERIFY3U(nvlist_pack(nvl, &packed, sizep, NV_ENCODE_NATIVE,
  84             KM_SLEEP), ==, 0);
  85         return (packed);
  86 }
  87
  88 /*ARGSUSED*/
  89 void
  90 fnvlist_pack_free(char *pack, size_t size)
  91 {
  92 #ifdef _KERNEL
  93         kmem_free(pack, size);
  94 #else
  95         free(pack);
  96 #endif
  97 }
  98
  99 nvlist_t *
 100 fnvlist_unpack(char *buf, size_t buflen)
 101 {
 102         nvlist_t *rv;
 103         VERIFY0(nvlist_unpack(buf, buflen, &rv, KM_SLEEP));
 104         return (rv);
 105 }
 106
 107 nvlist_t *
 108 fnvlist_dup(nvlist_t *nvl)
 109 {
 110         nvlist_t *rv;
 111         VERIFY0(nvlist_dup(nvl, &rv, KM_SLEEP));
 112         return (rv);
 113 }
 114
 115 void
 116 fnvlist_merge(nvlist_t *dst, nvlist_t *src)
 117 {
 118         VERIFY0(nvlist_merge(dst, src, KM_SLEEP));
 119 }
 120
 121 size_t
 122 fnvlist_num_pairs(nvlist_t *nvl)
 123 {
 124         size_t count = 0;
 125         nvpair_t *pair;
 126
 127         for (pair = nvlist_next_nvpair(nvl, 0); pair != NULL;
 128             pair = nvlist_next_nvpair(nvl, pair))
 129                 count++;
 130         return (count);
 131 }
 132
 133 void
 134 fnvlist_add_boolean(nvlist_t *nvl, const char *name)
 135 {
 136         VERIFY0(nvlist_add_boolean(nvl, name));
 137 }
 138
 139 void
 140 fnvlist_add_boolean_value(nvlist_t *nvl, const char *name, boolean_t val)
 141 {
 142         VERIFY0(nvlist_add_boolean_value(nvl, name, val));
 143 }
 144
 145 void
 146 fnvlist_add_byte(nvlist_t *nvl, const char *name, uchar_t val)
 147 {
 148         VERIFY0(nvlist_add_byte(nvl, name, val));
 149 }
 150
 151 void
 152 fnvlist_add_int8(nvlist_t *nvl, const char *name, int8_t val)
 153 {
 154         VERIFY0(nvlist_add_int8(nvl, name, val));
 155 }
 156
 157 void
 158 fnvlist_add_uint8(nvlist_t *nvl, const char *name, uint8_t val)
 159 {
 160         VERIFY0(nvlist_add_uint8(nvl, name, val));
 161 }
 162
 163 void
 164 fnvlist_add_int16(nvlist_t *nvl, const char *name, int16_t val)
 165 {
 166         VERIFY0(nvlist_add_int16(nvl, name, val));
 167 }
 168
 169 void
 170 fnvlist_add_uint16(nvlist_t *nvl, const char *name, uint16_t val)
 171 {
 172         VERIFY0(nvlist_add_uint16(nvl, name, val));
 173 }
 174
 175 void
 176 fnvlist_add_int32(nvlist_t *nvl, const char *name, int32_t val)
 177 {
 178         VERIFY0(nvlist_add_int32(nvl, name, val));
 179 }
 180
 181 void
 182 fnvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val)
 183 {
 184         VERIFY0(nvlist_add_uint32(nvl, name, val));
 185 }
 186
 187 void
 188 fnvlist_add_int64(nvlist_t *nvl, const char *name, int64_t val)
 189 {
 190         VERIFY0(nvlist_add_int64(nvl, name, val));
 191 }
 192
 193 void
 194 fnvlist_add_uint64(nvlist_t *nvl, const char *name, uint64_t val)
 195 {
 196         VERIFY0(nvlist_add_uint64(nvl, name, val));
 197 }
 198
 199 void
 200 fnvlist_add_string(nvlist_t *nvl, const char *name, const char *val)
 201 {
 202         VERIFY0(nvlist_add_string(nvl, name, val));
 203 }
 204
 205 void
 206 fnvlist_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val)
 207 {
 208         VERIFY0(nvlist_add_nvlist(nvl, name, val));
 209 }
 210
 211 void
 212 fnvlist_add_nvpair(nvlist_t *nvl, nvpair_t *pair)
 213 {
 214         VERIFY0(nvlist_add_nvpair(nvl, pair));
 215 }
 216
 217 void
 218 fnvlist_add_boolean_array(nvlist_t *nvl, const char *name,
 219     boolean_t *val, uint_t n)
 220 {
 221         VERIFY0(nvlist_add_boolean_array(nvl, name, val, n));
 222 }
 223
 224 void
 225 fnvlist_add_byte_array(nvlist_t *nvl, const char *name, uchar_t *val, uint_t n)
 226 {
 227         VERIFY0(nvlist_add_byte_array(nvl, name, val, n));
 228 }
 229
 230 void
 231 fnvlist_add_int8_array(nvlist_t *nvl, const char *name, int8_t *val, uint_t n)
 232 {
 233         VERIFY0(nvlist_add_int8_array(nvl, name, val, n));
 234 }
 235
 236 void
 237 fnvlist_add_uint8_array(nvlist_t *nvl, const char *name, uint8_t *val, uint_t n)
 238 {
 239         VERIFY0(nvlist_add_uint8_array(nvl, name, val, n));
 240 }
 241
 242 void
 243 fnvlist_add_int16_array(nvlist_t *nvl, const char *name, int16_t *val, uint_t n)
 244 {
 245         VERIFY0(nvlist_add_int16_array(nvl, name, val, n));
 246 }
 247
 248 void
 249 fnvlist_add_uint16_array(nvlist_t *nvl, const char *name,
 250     uint16_t *val, uint_t n)
 251 {
 252         VERIFY0(nvlist_add_uint16_array(nvl, name, val, n));
 253 }
 254
 255 void
 256 fnvlist_add_int32_array(nvlist_t *nvl, const char *name, int32_t *val, uint_t n)
 257 {
 258         VERIFY0(nvlist_add_int32_array(nvl, name, val, n));
 259 }
 260
 261 void
 262 fnvlist_add_uint32_array(nvlist_t *nvl, const char *name,
 263     uint32_t *val, uint_t n)
 264 {
 265         VERIFY0(nvlist_add_uint32_array(nvl, name, val, n));
 266 }
 267
 268 void
 269 fnvlist_add_int64_array(nvlist_t *nvl, const char *name, int64_t *val, uint_t n)
 270 {
 271         VERIFY0(nvlist_add_int64_array(nvl, name, val, n));
 272 }
 273
 274 void
 275 fnvlist_add_uint64_array(nvlist_t *nvl, const char *name,
 276     uint64_t *val, uint_t n)
 277 {
 278         VERIFY0(nvlist_add_uint64_array(nvl, name, val, n));
 279 }
 280
 281 void
 282 fnvlist_add_string_array(nvlist_t *nvl, const char *name,
 283     char * const *val, uint_t n)
 284 {
 285         VERIFY0(nvlist_add_string_array(nvl, name, val, n));
 286 }
 287
 288 void
 289 fnvlist_add_nvlist_array(nvlist_t *nvl, const char *name,
 290     nvlist_t **val, uint_t n)
 291 {
 292         VERIFY0(nvlist_add_nvlist_array(nvl, name, val, n));
 293 }
 294
 295 void
 296 fnvlist_remove(nvlist_t *nvl, const char *name)
 297 {
 298         VERIFY0(nvlist_remove_all(nvl, name));
 299 }
 300
 301 void
 302 fnvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *pair)
 303 {
 304         VERIFY0(nvlist_remove_nvpair(nvl, pair));
 305 }
 306
 307 nvpair_t *
 308 fnvlist_lookup_nvpair(nvlist_t *nvl, const char *name)
 309 {
 310         nvpair_t *rv;
 311         VERIFY0(nvlist_lookup_nvpair(nvl, name, &rv));
 312         return (rv);
 313 }
 314
 315 /* returns B_TRUE if the entry exists */
 316 boolean_t
 317 fnvlist_lookup_boolean(nvlist_t *nvl, const char *name)
 318 {
 319         return (nvlist_lookup_boolean(nvl, name) == 0);
 320 }
 321
 322 boolean_t
 323 fnvlist_lookup_boolean_value(nvlist_t *nvl, const char *name)
 324 {
 325         boolean_t rv;
 326         VERIFY0(nvlist_lookup_boolean_value(nvl, name, &rv));
 327         return (rv);
 328 }
 329
 330 uchar_t
 331 fnvlist_lookup_byte(nvlist_t *nvl, const char *name)
 332 {
 333         uchar_t rv;
 334         VERIFY0(nvlist_lookup_byte(nvl, name, &rv));
 335         return (rv);
 336 }
 337
 338 int8_t
 339 fnvlist_lookup_int8(nvlist_t *nvl, const char *name)
 340 {
 341         int8_t rv;
 342         VERIFY0(nvlist_lookup_int8(nvl, name, &rv));
 343         return (rv);
 344 }
 345
 346 int16_t
 347 fnvlist_lookup_int16(nvlist_t *nvl, const char *name)
 348 {
 349         int16_t rv;
 350         VERIFY0(nvlist_lookup_int16(nvl, name, &rv));
 351         return (rv);
 352 }
 353
 354 int32_t
 355 fnvlist_lookup_int32(nvlist_t *nvl, const char *name)
 356 {
 357         int32_t rv;
 358         VERIFY0(nvlist_lookup_int32(nvl, name, &rv));
 359         return (rv);
 360 }
 361
 362 int64_t
 363 fnvlist_lookup_int64(nvlist_t *nvl, const char *name)
 364 {
 365         int64_t rv;
 366         VERIFY0(nvlist_lookup_int64(nvl, name, &rv));
 367         return (rv);
 368 }
 369
 370 uint8_t
 371 fnvlist_lookup_uint8_t(nvlist_t *nvl, const char *name)
 372 {
 373         uint8_t rv;
 374         VERIFY0(nvlist_lookup_uint8(nvl, name, &rv));
 375         return (rv);
 376 }
 377
 378 uint16_t
 379 fnvlist_lookup_uint16(nvlist_t *nvl, const char *name)
 380 {
 381         uint16_t rv;
 382         VERIFY0(nvlist_lookup_uint16(nvl, name, &rv));
 383         return (rv);
 384 }
 385
 386 uint32_t
 387 fnvlist_lookup_uint32(nvlist_t *nvl, const char *name)
 388 {
 389         uint32_t rv;
 390         VERIFY0(nvlist_lookup_uint32(nvl, name, &rv));
 391         return (rv);
 392 }
 393
 394 uint64_t
 395 fnvlist_lookup_uint64(nvlist_t *nvl, const char *name)
 396 {
 397         uint64_t rv;
 398         VERIFY0(nvlist_lookup_uint64(nvl, name, &rv));
 399         return (rv);
 400 }
 401
 402 char *
 403 fnvlist_lookup_string(nvlist_t *nvl, const char *name)
 404 {
 405         char *rv;
 406         VERIFY0(nvlist_lookup_string(nvl, name, &rv));
 407         return (rv);
 408 }
 409
 410 nvlist_t *
 411 fnvlist_lookup_nvlist(nvlist_t *nvl, const char *name)
 412 {
 413         nvlist_t *rv;
 414         VERIFY0(nvlist_lookup_nvlist(nvl, name, &rv));
 415         return (rv);
 416 }
 417
 418 boolean_t
 419 fnvpair_value_boolean_value(nvpair_t *nvp)
 420 {
 421         boolean_t rv;
 422         VERIFY0(nvpair_value_boolean_value(nvp, &rv));
 423         return (rv);
 424 }
 425
 426 uchar_t
 427 fnvpair_value_byte(nvpair_t *nvp)
 428 {
 429         uchar_t rv;
 430         VERIFY0(nvpair_value_byte(nvp, &rv));
 431         return (rv);
 432 }
 433
 434 int8_t
 435 fnvpair_value_int8(nvpair_t *nvp)
 436 {
 437         int8_t rv;
 438         VERIFY0(nvpair_value_int8(nvp, &rv));
 439         return (rv);
 440 }
 441
 442 int16_t
 443 fnvpair_value_int16(nvpair_t *nvp)
 444 {
 445         int16_t rv;
 446         VERIFY0(nvpair_value_int16(nvp, &rv));
 447         return (rv);
 448 }
 449
 450 int32_t
 451 fnvpair_value_int32(nvpair_t *nvp)
 452 {
 453         int32_t rv;
 454         VERIFY0(nvpair_value_int32(nvp, &rv));
 455         return (rv);
 456 }
 457
 458 int64_t
 459 fnvpair_value_int64(nvpair_t *nvp)
 460 {
 461         int64_t rv;
 462         VERIFY0(nvpair_value_int64(nvp, &rv));
 463         return (rv);
 464 }
 465
 466 uint8_t
 467 fnvpair_value_uint8_t(nvpair_t *nvp)
 468 {
 469         uint8_t rv;
 470         VERIFY0(nvpair_value_uint8(nvp, &rv));
 471         return (rv);
 472 }
 473
 474 uint16_t
 475 fnvpair_value_uint16(nvpair_t *nvp)
 476 {
 477         uint16_t rv;
 478         VERIFY0(nvpair_value_uint16(nvp, &rv));
 479         return (rv);
 480 }
 481
 482 uint32_t
 483 fnvpair_value_uint32(nvpair_t *nvp)
 484 {
 485         uint32_t rv;
 486         VERIFY0(nvpair_value_uint32(nvp, &rv));
 487         return (rv);
 488 }
 489
 490 uint64_t
 491 fnvpair_value_uint64(nvpair_t *nvp)
 492 {
 493         uint64_t rv;
 494         VERIFY0(nvpair_value_uint64(nvp, &rv));
 495         return (rv);
 496 }
 497
 498 char *
 499 fnvpair_value_string(nvpair_t *nvp)
 500 {
 501         char *rv;
 502         VERIFY0(nvpair_value_string(nvp, &rv));
 503         return (rv);
 504 }
 505
 506 nvlist_t *
 507 fnvpair_value_nvlist(nvpair_t *nvp)
 508 {
 509         nvlist_t *rv;
 510         VERIFY0(nvpair_value_nvlist(nvp, &rv));
 511         return (rv);
 512 }