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 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
25 */
26
27 #include <sys/nvpair.h>
28 #include <sys/kmem.h>
29 #include <sys/debug.h>
30 #ifndef _KERNEL
31 #include <stdlib.h>
32 #endif
33
34 #pragma weak fnvlist_lookup_uint8_t = fnvlist_lookup_uint8
35 #pragma weak fnvpair_value_uint8_t = fnvpair_value_uint8
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 void
122 fnvlist_add_boolean(nvlist_t *nvl, const char *name)
123 {
124 VERIFY0(nvlist_add_boolean(nvl, name));
125 }
126
127 void
128 fnvlist_add_boolean_value(nvlist_t *nvl, const char *name, boolean_t val)
129 {
130 VERIFY0(nvlist_add_boolean_value(nvl, name, val));
131 }
132
133 void
134 fnvlist_add_byte(nvlist_t *nvl, const char *name, uchar_t val)
135 {
136 VERIFY0(nvlist_add_byte(nvl, name, val));
137 }
138
139 void
140 fnvlist_add_int8(nvlist_t *nvl, const char *name, int8_t val)
141 {
142 VERIFY0(nvlist_add_int8(nvl, name, val));
143 }
144
145 void
146 fnvlist_add_uint8(nvlist_t *nvl, const char *name, uint8_t val)
147 {
148 VERIFY0(nvlist_add_uint8(nvl, name, val));
149 }
150
151 void
152 fnvlist_add_int16(nvlist_t *nvl, const char *name, int16_t val)
153 {
154 VERIFY0(nvlist_add_int16(nvl, name, val));
155 }
156
157 void
158 fnvlist_add_uint16(nvlist_t *nvl, const char *name, uint16_t val)
159 {
160 VERIFY0(nvlist_add_uint16(nvl, name, val));
161 }
162
163 void
164 fnvlist_add_int32(nvlist_t *nvl, const char *name, int32_t val)
165 {
166 VERIFY0(nvlist_add_int32(nvl, name, val));
167 }
168
169 void
170 fnvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val)
171 {
172 VERIFY0(nvlist_add_uint32(nvl, name, val));
173 }
174
175 void
176 fnvlist_add_int64(nvlist_t *nvl, const char *name, int64_t val)
177 {
178 VERIFY0(nvlist_add_int64(nvl, name, val));
179 }
180
181 void
182 fnvlist_add_uint64(nvlist_t *nvl, const char *name, uint64_t val)
183 {
184 VERIFY0(nvlist_add_uint64(nvl, name, val));
185 }
186
187 void
188 fnvlist_add_string(nvlist_t *nvl, const char *name, const char *val)
189 {
190 VERIFY0(nvlist_add_string(nvl, name, val));
191 }
192
193 void
194 fnvlist_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val)
195 {
196 VERIFY0(nvlist_add_nvlist(nvl, name, val));
197 }
198
199 void
200 fnvlist_add_nvpair(nvlist_t *nvl, nvpair_t *pair)
201 {
202 VERIFY0(nvlist_add_nvpair(nvl, pair));
203 }
204
205 void
206 fnvlist_add_boolean_array(nvlist_t *nvl, const char *name,
207 boolean_t *val, uint_t n)
208 {
209 VERIFY0(nvlist_add_boolean_array(nvl, name, val, n));
210 }
211
212 void
213 fnvlist_add_byte_array(nvlist_t *nvl, const char *name, uchar_t *val, uint_t n)
214 {
215 VERIFY0(nvlist_add_byte_array(nvl, name, val, n));
216 }
217
218 void
219 fnvlist_add_int8_array(nvlist_t *nvl, const char *name, int8_t *val, uint_t n)
220 {
221 VERIFY0(nvlist_add_int8_array(nvl, name, val, n));
222 }
223
224 void
225 fnvlist_add_uint8_array(nvlist_t *nvl, const char *name, uint8_t *val, uint_t n)
226 {
227 VERIFY0(nvlist_add_uint8_array(nvl, name, val, n));
228 }
229
230 void
231 fnvlist_add_int16_array(nvlist_t *nvl, const char *name, int16_t *val, uint_t n)
232 {
233 VERIFY0(nvlist_add_int16_array(nvl, name, val, n));
234 }
235
236 void
237 fnvlist_add_uint16_array(nvlist_t *nvl, const char *name,
238 uint16_t *val, uint_t n)
239 {
240 VERIFY0(nvlist_add_uint16_array(nvl, name, val, n));
241 }
242
243 void
244 fnvlist_add_int32_array(nvlist_t *nvl, const char *name, int32_t *val, uint_t n)
245 {
246 VERIFY0(nvlist_add_int32_array(nvl, name, val, n));
247 }
248
249 void
250 fnvlist_add_uint32_array(nvlist_t *nvl, const char *name,
251 uint32_t *val, uint_t n)
252 {
253 VERIFY0(nvlist_add_uint32_array(nvl, name, val, n));
254 }
255
256 void
257 fnvlist_add_int64_array(nvlist_t *nvl, const char *name, int64_t *val, uint_t n)
258 {
259 VERIFY0(nvlist_add_int64_array(nvl, name, val, n));
260 }
261
262 void
263 fnvlist_add_uint64_array(nvlist_t *nvl, const char *name,
264 uint64_t *val, uint_t n)
265 {
266 VERIFY0(nvlist_add_uint64_array(nvl, name, val, n));
267 }
268
269 void
270 fnvlist_add_string_array(nvlist_t *nvl, const char *name,
271 char * const *val, uint_t n)
272 {
273 VERIFY0(nvlist_add_string_array(nvl, name, val, n));
274 }
275
276 void
277 fnvlist_add_nvlist_array(nvlist_t *nvl, const char *name,
278 nvlist_t **val, uint_t n)
279 {
280 VERIFY0(nvlist_add_nvlist_array(nvl, name, val, n));
281 }
282
283 void
284 fnvlist_remove(nvlist_t *nvl, const char *name)
285 {
286 VERIFY0(nvlist_remove_all(nvl, name));
287 }
288
289 void
290 fnvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *pair)
291 {
292 VERIFY0(nvlist_remove_nvpair(nvl, pair));
293 }
294
295 nvpair_t *
296 fnvlist_lookup_nvpair(nvlist_t *nvl, const char *name)
297 {
298 nvpair_t *rv;
299 VERIFY0(nvlist_lookup_nvpair(nvl, name, &rv));
300 return (rv);
301 }
302
303 /* returns B_TRUE if the entry exists */
304 boolean_t
305 fnvlist_lookup_boolean(nvlist_t *nvl, const char *name)
306 {
307 return (nvlist_lookup_boolean(nvl, name) == 0);
308 }
309
310 boolean_t
311 fnvlist_lookup_boolean_value(nvlist_t *nvl, const char *name)
312 {
313 boolean_t rv;
314 VERIFY0(nvlist_lookup_boolean_value(nvl, name, &rv));
315 return (rv);
316 }
317
318 uchar_t
319 fnvlist_lookup_byte(nvlist_t *nvl, const char *name)
320 {
321 uchar_t rv;
322 VERIFY0(nvlist_lookup_byte(nvl, name, &rv));
323 return (rv);
324 }
325
326 int8_t
327 fnvlist_lookup_int8(nvlist_t *nvl, const char *name)
328 {
329 int8_t rv;
330 VERIFY0(nvlist_lookup_int8(nvl, name, &rv));
331 return (rv);
332 }
333
334 int16_t
335 fnvlist_lookup_int16(nvlist_t *nvl, const char *name)
336 {
337 int16_t rv;
338 VERIFY0(nvlist_lookup_int16(nvl, name, &rv));
339 return (rv);
340 }
341
342 int32_t
343 fnvlist_lookup_int32(nvlist_t *nvl, const char *name)
344 {
345 int32_t rv;
346 VERIFY0(nvlist_lookup_int32(nvl, name, &rv));
347 return (rv);
348 }
349
350 int64_t
351 fnvlist_lookup_int64(nvlist_t *nvl, const char *name)
352 {
353 int64_t rv;
354 VERIFY0(nvlist_lookup_int64(nvl, name, &rv));
355 return (rv);
356 }
357
358 uint8_t
359 fnvlist_lookup_uint8(nvlist_t *nvl, const char *name)
360 {
361 uint8_t rv;
362 VERIFY0(nvlist_lookup_uint8(nvl, name, &rv));
363 return (rv);
364 }
365
366 uint16_t
367 fnvlist_lookup_uint16(nvlist_t *nvl, const char *name)
368 {
369 uint16_t rv;
370 VERIFY0(nvlist_lookup_uint16(nvl, name, &rv));
371 return (rv);
372 }
373
374 uint32_t
375 fnvlist_lookup_uint32(nvlist_t *nvl, const char *name)
376 {
377 uint32_t rv;
378 VERIFY0(nvlist_lookup_uint32(nvl, name, &rv));
379 return (rv);
380 }
381
382 uint64_t
383 fnvlist_lookup_uint64(nvlist_t *nvl, const char *name)
384 {
385 uint64_t rv;
386 VERIFY0(nvlist_lookup_uint64(nvl, name, &rv));
387 return (rv);
388 }
389
390 char *
391 fnvlist_lookup_string(nvlist_t *nvl, const char *name)
392 {
393 char *rv;
394 VERIFY0(nvlist_lookup_string(nvl, name, &rv));
395 return (rv);
396 }
397
398 nvlist_t *
399 fnvlist_lookup_nvlist(nvlist_t *nvl, const char *name)
400 {
401 nvlist_t *rv;
402 VERIFY0(nvlist_lookup_nvlist(nvl, name, &rv));
403 return (rv);
404 }
405
406 boolean_t
407 fnvpair_value_boolean_value(nvpair_t *nvp)
408 {
409 boolean_t rv;
410 VERIFY0(nvpair_value_boolean_value(nvp, &rv));
411 return (rv);
412 }
413
414 uchar_t
415 fnvpair_value_byte(nvpair_t *nvp)
416 {
417 uchar_t rv;
418 VERIFY0(nvpair_value_byte(nvp, &rv));
419 return (rv);
420 }
421
422 int8_t
423 fnvpair_value_int8(nvpair_t *nvp)
424 {
425 int8_t rv;
426 VERIFY0(nvpair_value_int8(nvp, &rv));
427 return (rv);
428 }
429
430 int16_t
431 fnvpair_value_int16(nvpair_t *nvp)
432 {
433 int16_t rv;
434 VERIFY0(nvpair_value_int16(nvp, &rv));
435 return (rv);
436 }
437
438 int32_t
439 fnvpair_value_int32(nvpair_t *nvp)
440 {
441 int32_t rv;
442 VERIFY0(nvpair_value_int32(nvp, &rv));
443 return (rv);
444 }
445
446 int64_t
447 fnvpair_value_int64(nvpair_t *nvp)
448 {
449 int64_t rv;
450 VERIFY0(nvpair_value_int64(nvp, &rv));
451 return (rv);
452 }
453
454 uint8_t
455 fnvpair_value_uint8(nvpair_t *nvp)
456 {
457 uint8_t rv;
458 VERIFY0(nvpair_value_uint8(nvp, &rv));
459 return (rv);
460 }
461
462 uint16_t
463 fnvpair_value_uint16(nvpair_t *nvp)
464 {
465 uint16_t rv;
466 VERIFY0(nvpair_value_uint16(nvp, &rv));
467 return (rv);
468 }
469
470 uint32_t
471 fnvpair_value_uint32(nvpair_t *nvp)
472 {
473 uint32_t rv;
474 VERIFY0(nvpair_value_uint32(nvp, &rv));
475 return (rv);
476 }
477
478 uint64_t
479 fnvpair_value_uint64(nvpair_t *nvp)
480 {
481 uint64_t rv;
482 VERIFY0(nvpair_value_uint64(nvp, &rv));
483 return (rv);
484 }
485
486 char *
487 fnvpair_value_string(nvpair_t *nvp)
488 {
489 char *rv;
490 VERIFY0(nvpair_value_string(nvp, &rv));
491 return (rv);
492 }
493
494 nvlist_t *
495 fnvpair_value_nvlist(nvpair_t *nvp)
496 {
497 nvlist_t *rv;
498 VERIFY0(nvpair_value_nvlist(nvp, &rv));
499 return (rv);
500 }
501
502 double
503 fnvpair_value_double(nvpair_t *nvp)
504 {
505 double rv;
506 VERIFY0(nvpair_value_double(nvp, &rv));
507 return (rv);
508 }
509
510 hrtime_t
511 fnvpair_value_hrtime(nvpair_t *nvp)
512 {
513 hrtime_t rv;
514 VERIFY0(nvpair_value_hrtime(nvp, &rv));
515 return (rv);
516 }