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