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