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 *
fnvlist_alloc(void)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
fnvlist_free(nvlist_t * nvl)62 fnvlist_free(nvlist_t *nvl)
63 {
64 nvlist_free(nvl);
65 }
66
67 size_t
fnvlist_size(nvlist_t * nvl)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 *
fnvlist_pack(nvlist_t * nvl,size_t * sizep)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
fnvlist_pack_free(char * pack,size_t size)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 *
fnvlist_unpack(char * buf,size_t buflen)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 *
fnvlist_dup(nvlist_t * nvl)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
fnvlist_merge(nvlist_t * dst,nvlist_t * src)116 fnvlist_merge(nvlist_t *dst, nvlist_t *src)
117 {
118 VERIFY0(nvlist_merge(dst, src, KM_SLEEP));
119 }
120
121 size_t
fnvlist_num_pairs(nvlist_t * nvl)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
fnvlist_add_boolean(nvlist_t * nvl,const char * name)134 fnvlist_add_boolean(nvlist_t *nvl, const char *name)
135 {
136 VERIFY0(nvlist_add_boolean(nvl, name));
137 }
138
139 void
fnvlist_add_boolean_value(nvlist_t * nvl,const char * name,boolean_t val)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
fnvlist_add_byte(nvlist_t * nvl,const char * name,uchar_t val)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
fnvlist_add_int8(nvlist_t * nvl,const char * name,int8_t val)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
fnvlist_add_uint8(nvlist_t * nvl,const char * name,uint8_t val)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
fnvlist_add_int16(nvlist_t * nvl,const char * name,int16_t val)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
fnvlist_add_uint16(nvlist_t * nvl,const char * name,uint16_t val)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
fnvlist_add_int32(nvlist_t * nvl,const char * name,int32_t val)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
fnvlist_add_uint32(nvlist_t * nvl,const char * name,uint32_t val)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
fnvlist_add_int64(nvlist_t * nvl,const char * name,int64_t val)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
fnvlist_add_uint64(nvlist_t * nvl,const char * name,uint64_t val)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
fnvlist_add_string(nvlist_t * nvl,const char * name,const char * val)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
fnvlist_add_nvlist(nvlist_t * nvl,const char * name,nvlist_t * val)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
fnvlist_add_nvpair(nvlist_t * nvl,nvpair_t * pair)212 fnvlist_add_nvpair(nvlist_t *nvl, nvpair_t *pair)
213 {
214 VERIFY0(nvlist_add_nvpair(nvl, pair));
215 }
216
217 void
fnvlist_add_boolean_array(nvlist_t * nvl,const char * name,boolean_t * val,uint_t n)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
fnvlist_add_byte_array(nvlist_t * nvl,const char * name,uchar_t * val,uint_t n)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
fnvlist_add_int8_array(nvlist_t * nvl,const char * name,int8_t * val,uint_t n)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
fnvlist_add_uint8_array(nvlist_t * nvl,const char * name,uint8_t * val,uint_t n)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
fnvlist_add_int16_array(nvlist_t * nvl,const char * name,int16_t * val,uint_t n)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
fnvlist_add_uint16_array(nvlist_t * nvl,const char * name,uint16_t * val,uint_t n)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
fnvlist_add_int32_array(nvlist_t * nvl,const char * name,int32_t * val,uint_t n)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
fnvlist_add_uint32_array(nvlist_t * nvl,const char * name,uint32_t * val,uint_t n)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
fnvlist_add_int64_array(nvlist_t * nvl,const char * name,int64_t * val,uint_t n)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
fnvlist_add_uint64_array(nvlist_t * nvl,const char * name,uint64_t * val,uint_t n)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
fnvlist_add_string_array(nvlist_t * nvl,const char * name,char * const * val,uint_t n)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
fnvlist_add_nvlist_array(nvlist_t * nvl,const char * name,nvlist_t ** val,uint_t n)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
fnvlist_remove(nvlist_t * nvl,const char * name)296 fnvlist_remove(nvlist_t *nvl, const char *name)
297 {
298 VERIFY0(nvlist_remove_all(nvl, name));
299 }
300
301 void
fnvlist_remove_nvpair(nvlist_t * nvl,nvpair_t * pair)302 fnvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *pair)
303 {
304 VERIFY0(nvlist_remove_nvpair(nvl, pair));
305 }
306
307 nvpair_t *
fnvlist_lookup_nvpair(nvlist_t * nvl,const char * name)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
fnvlist_lookup_boolean(nvlist_t * nvl,const char * name)317 fnvlist_lookup_boolean(nvlist_t *nvl, const char *name)
318 {
319 return (nvlist_lookup_boolean(nvl, name) == 0);
320 }
321
322 boolean_t
fnvlist_lookup_boolean_value(nvlist_t * nvl,const char * name)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
fnvlist_lookup_byte(nvlist_t * nvl,const char * name)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
fnvlist_lookup_int8(nvlist_t * nvl,const char * name)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
fnvlist_lookup_int16(nvlist_t * nvl,const char * name)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
fnvlist_lookup_int32(nvlist_t * nvl,const char * name)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
fnvlist_lookup_int64(nvlist_t * nvl,const char * name)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
fnvlist_lookup_uint8_t(nvlist_t * nvl,const char * name)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
fnvlist_lookup_uint16(nvlist_t * nvl,const char * name)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
fnvlist_lookup_uint32(nvlist_t * nvl,const char * name)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
fnvlist_lookup_uint64(nvlist_t * nvl,const char * name)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 *
fnvlist_lookup_string(nvlist_t * nvl,const char * name)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 *
fnvlist_lookup_nvlist(nvlist_t * nvl,const char * name)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
fnvpair_value_boolean_value(nvpair_t * nvp)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
fnvpair_value_byte(nvpair_t * nvp)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
fnvpair_value_int8(nvpair_t * nvp)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
fnvpair_value_int16(nvpair_t * nvp)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
fnvpair_value_int32(nvpair_t * nvp)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
fnvpair_value_int64(nvpair_t * nvp)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
fnvpair_value_uint8_t(nvpair_t * nvp)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
fnvpair_value_uint16(nvpair_t * nvp)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
fnvpair_value_uint32(nvpair_t * nvp)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
fnvpair_value_uint64(nvpair_t * nvp)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 *
fnvpair_value_string(nvpair_t * nvp)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 *
fnvpair_value_nvlist(nvpair_t * nvp)507 fnvpair_value_nvlist(nvpair_t *nvp)
508 {
509 nvlist_t *rv;
510 VERIFY0(nvpair_value_nvlist(nvp, &rv));
511 return (rv);
512 }
513