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