opensolaris_fnvpair.c revision 292973 
1
2/*
3 * CDDL HEADER START
4 *
5 * The contents of this file are subject to the terms of the
6 * Common Development and Distribution License (the "License").
7 * You may not use this file except in compliance with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22
23/*
24 * Copyright (c) 2012 by Delphix. All rights reserved.
25 */
26
27#include <sys/nvpair.h>
28#ifndef _KERNEL
29#include <sys/zfs_context.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
53nvlist_t *
54fnvlist_alloc(void)
55{
56	nvlist_t *nvl;
57	VERIFY0(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP));
58	return (nvl);
59}
60
61void
62fnvlist_free(nvlist_t *nvl)
63{
64	nvlist_free(nvl);
65}
66
67size_t
68fnvlist_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 */
79char *
80fnvlist_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*/
89void
90fnvlist_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
99nvlist_t *
100fnvlist_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
107nvlist_t *
108fnvlist_dup(nvlist_t *nvl)
109{
110	nvlist_t *rv;
111	VERIFY0(nvlist_dup(nvl, &rv, KM_SLEEP));
112	return (rv);
113}
114
115void
116fnvlist_merge(nvlist_t *dst, nvlist_t *src)
117{
118	VERIFY0(nvlist_merge(dst, src, KM_SLEEP));
119}
120
121size_t
122fnvlist_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
133void
134fnvlist_add_boolean(nvlist_t *nvl, const char *name)
135{
136	VERIFY0(nvlist_add_boolean(nvl, name));
137}
138
139void
140fnvlist_add_boolean_value(nvlist_t *nvl, const char *name, boolean_t val)
141{
142	VERIFY0(nvlist_add_boolean_value(nvl, name, val));
143}
144
145void
146fnvlist_add_byte(nvlist_t *nvl, const char *name, uchar_t val)
147{
148	VERIFY0(nvlist_add_byte(nvl, name, val));
149}
150
151void
152fnvlist_add_int8(nvlist_t *nvl, const char *name, int8_t val)
153{
154	VERIFY0(nvlist_add_int8(nvl, name, val));
155}
156
157void
158fnvlist_add_uint8(nvlist_t *nvl, const char *name, uint8_t val)
159{
160	VERIFY0(nvlist_add_uint8(nvl, name, val));
161}
162
163void
164fnvlist_add_int16(nvlist_t *nvl, const char *name, int16_t val)
165{
166	VERIFY0(nvlist_add_int16(nvl, name, val));
167}
168
169void
170fnvlist_add_uint16(nvlist_t *nvl, const char *name, uint16_t val)
171{
172	VERIFY0(nvlist_add_uint16(nvl, name, val));
173}
174
175void
176fnvlist_add_int32(nvlist_t *nvl, const char *name, int32_t val)
177{
178	VERIFY0(nvlist_add_int32(nvl, name, val));
179}
180
181void
182fnvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val)
183{
184	VERIFY0(nvlist_add_uint32(nvl, name, val));
185}
186
187void
188fnvlist_add_int64(nvlist_t *nvl, const char *name, int64_t val)
189{
190	VERIFY0(nvlist_add_int64(nvl, name, val));
191}
192
193void
194fnvlist_add_uint64(nvlist_t *nvl, const char *name, uint64_t val)
195{
196	VERIFY0(nvlist_add_uint64(nvl, name, val));
197}
198
199void
200fnvlist_add_string(nvlist_t *nvl, const char *name, const char *val)
201{
202	VERIFY0(nvlist_add_string(nvl, name, val));
203}
204
205void
206fnvlist_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val)
207{
208	VERIFY0(nvlist_add_nvlist(nvl, name, val));
209}
210
211void
212fnvlist_add_nvpair(nvlist_t *nvl, nvpair_t *pair)
213{
214	VERIFY0(nvlist_add_nvpair(nvl, pair));
215}
216
217void
218fnvlist_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
224void
225fnvlist_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
230void
231fnvlist_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
236void
237fnvlist_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
242void
243fnvlist_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
248void
249fnvlist_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
255void
256fnvlist_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
261void
262fnvlist_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
268void
269fnvlist_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
274void
275fnvlist_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
281void
282fnvlist_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
288void
289fnvlist_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
295void
296fnvlist_remove(nvlist_t *nvl, const char *name)
297{
298	VERIFY0(nvlist_remove_all(nvl, name));
299}
300
301void
302fnvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *pair)
303{
304	VERIFY0(nvlist_remove_nvpair(nvl, pair));
305}
306
307nvpair_t *
308fnvlist_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 */
316boolean_t
317fnvlist_lookup_boolean(nvlist_t *nvl, const char *name)
318{
319	return (nvlist_lookup_boolean(nvl, name) == 0);
320}
321
322boolean_t
323fnvlist_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
330uchar_t
331fnvlist_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
338int8_t
339fnvlist_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
346int16_t
347fnvlist_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
354int32_t
355fnvlist_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
362int64_t
363fnvlist_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
370uint8_t
371fnvlist_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
378uint16_t
379fnvlist_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
386uint32_t
387fnvlist_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
394uint64_t
395fnvlist_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
402char *
403fnvlist_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
410nvlist_t *
411fnvlist_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
418boolean_t
419fnvpair_value_boolean_value(nvpair_t *nvp)
420{
421	boolean_t rv;
422	VERIFY0(nvpair_value_boolean_value(nvp, &rv));
423	return (rv);
424}
425
426uchar_t
427fnvpair_value_byte(nvpair_t *nvp)
428{
429	uchar_t rv;
430	VERIFY0(nvpair_value_byte(nvp, &rv));
431	return (rv);
432}
433
434int8_t
435fnvpair_value_int8(nvpair_t *nvp)
436{
437	int8_t rv;
438	VERIFY0(nvpair_value_int8(nvp, &rv));
439	return (rv);
440}
441
442int16_t
443fnvpair_value_int16(nvpair_t *nvp)
444{
445	int16_t rv;
446	VERIFY0(nvpair_value_int16(nvp, &rv));
447	return (rv);
448}
449
450int32_t
451fnvpair_value_int32(nvpair_t *nvp)
452{
453	int32_t rv;
454	VERIFY0(nvpair_value_int32(nvp, &rv));
455	return (rv);
456}
457
458int64_t
459fnvpair_value_int64(nvpair_t *nvp)
460{
461	int64_t rv;
462	VERIFY0(nvpair_value_int64(nvp, &rv));
463	return (rv);
464}
465
466uint8_t
467fnvpair_value_uint8_t(nvpair_t *nvp)
468{
469	uint8_t rv;
470	VERIFY0(nvpair_value_uint8(nvp, &rv));
471	return (rv);
472}
473
474uint16_t
475fnvpair_value_uint16(nvpair_t *nvp)
476{
477	uint16_t rv;
478	VERIFY0(nvpair_value_uint16(nvp, &rv));
479	return (rv);
480}
481
482uint32_t
483fnvpair_value_uint32(nvpair_t *nvp)
484{
485	uint32_t rv;
486	VERIFY0(nvpair_value_uint32(nvp, &rv));
487	return (rv);
488}
489
490uint64_t
491fnvpair_value_uint64(nvpair_t *nvp)
492{
493	uint64_t rv;
494	VERIFY0(nvpair_value_uint64(nvp, &rv));
495	return (rv);
496}
497
498char *
499fnvpair_value_string(nvpair_t *nvp)
500{
501	char *rv;
502	VERIFY0(nvpair_value_string(nvp, &rv));
503	return (rv);
504}
505
506nvlist_t *
507fnvpair_value_nvlist(nvpair_t *nvp)
508{
509	nvlist_t *rv;
510	VERIFY0(nvpair_value_nvlist(nvp, &rv));
511	return (rv);
512}
513