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 by Delphix. All rights reserved. 24 */ 25 26 #include <sys/nvpair.h> 27 #ifndef _KERNEL 28 #include <sys/zfs_context.h> 29 #include <stdlib.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 } 513