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