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