]> git.proxmox.com Git - mirror_zfs.git/blame - module/nvpair/fnvpair.c
projects / mirror_zfs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Delay injection can cause indefinitely hung zios
[mirror_zfs.git] / module / nvpair / fnvpair.c
CommitLineData
9ae529ec
CS		 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/*
95542372 23 * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
9ae529ec
CS		 24 */
25
26#include <sys/nvpair.h>
27#include <sys/kmem.h>
28#include <sys/debug.h>
13fe0198 29#include <sys/param.h>
9ae529ec
CS		 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;
c99c9001 54 VERIFY0(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP));
9ae529ec
CS		 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;
c99c9001 68 VERIFY0(nvlist_size(nvl, &size, NV_ENCODE_NATIVE));
9ae529ec
CS		 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;
c99c9001 100 VERIFY0(nvlist_unpack(buf, buflen, &rv, KM_SLEEP));
9ae529ec
CS		 101 return (rv);
102}
103
104nvlist_t *
105fnvlist_dup(nvlist_t *nvl)
106{
107 nvlist_t *rv;
c99c9001 108 VERIFY0(nvlist_dup(nvl, &rv, KM_SLEEP));
9ae529ec
CS		 109 return (rv);
110}
111
112void
113fnvlist_merge(nvlist_t *dst, nvlist_t *src)
114{
c99c9001 115 VERIFY0(nvlist_merge(dst, src, KM_SLEEP));
9ae529ec
CS		 116}
117
13fe0198
MA		 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
9ae529ec
CS		 130void
131fnvlist_add_boolean(nvlist_t *nvl, const char *name)
132{
c99c9001 133 VERIFY0(nvlist_add_boolean(nvl, name));
9ae529ec
CS		 134}
135
136void
137fnvlist_add_boolean_value(nvlist_t *nvl, const char *name, boolean_t val)
138{
c99c9001 139 VERIFY0(nvlist_add_boolean_value(nvl, name, val));
9ae529ec
CS		 140}
141
142void
143fnvlist_add_byte(nvlist_t *nvl, const char *name, uchar_t val)
144{
c99c9001 145 VERIFY0(nvlist_add_byte(nvl, name, val));
9ae529ec
CS		 146}
147
148void
149fnvlist_add_int8(nvlist_t *nvl, const char *name, int8_t val)
150{
c99c9001 151 VERIFY0(nvlist_add_int8(nvl, name, val));
9ae529ec
CS		 152}
153
154void
155fnvlist_add_uint8(nvlist_t *nvl, const char *name, uint8_t val)
156{
c99c9001 157 VERIFY0(nvlist_add_uint8(nvl, name, val));
9ae529ec
CS		 158}
159
160void
161fnvlist_add_int16(nvlist_t *nvl, const char *name, int16_t val)
162{
c99c9001 163 VERIFY0(nvlist_add_int16(nvl, name, val));
9ae529ec
CS		 164}
165
166void
167fnvlist_add_uint16(nvlist_t *nvl, const char *name, uint16_t val)
168{
c99c9001 169 VERIFY0(nvlist_add_uint16(nvl, name, val));
9ae529ec
CS		 170}
171
172void
173fnvlist_add_int32(nvlist_t *nvl, const char *name, int32_t val)
174{
c99c9001 175 VERIFY0(nvlist_add_int32(nvl, name, val));
9ae529ec
CS		 176}
177
178void
179fnvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val)
180{
c99c9001 181 VERIFY0(nvlist_add_uint32(nvl, name, val));
9ae529ec
CS		 182}
183
184void
185fnvlist_add_int64(nvlist_t *nvl, const char *name, int64_t val)
186{
c99c9001 187 VERIFY0(nvlist_add_int64(nvl, name, val));
9ae529ec
CS		 188}
189
190void
191fnvlist_add_uint64(nvlist_t *nvl, const char *name, uint64_t val)
192{
c99c9001 193 VERIFY0(nvlist_add_uint64(nvl, name, val));
9ae529ec
CS		 194}
195
196void
197fnvlist_add_string(nvlist_t *nvl, const char *name, const char *val)
198{
c99c9001 199 VERIFY0(nvlist_add_string(nvl, name, val));
9ae529ec
CS		 200}
201
202void
203fnvlist_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val)
204{
c99c9001 205 VERIFY0(nvlist_add_nvlist(nvl, name, val));
9ae529ec
CS		 206}
207
208void
209fnvlist_add_nvpair(nvlist_t *nvl, nvpair_t *pair)
210{
c99c9001 211 VERIFY0(nvlist_add_nvpair(nvl, pair));
9ae529ec
CS		 212}
213
214void
215fnvlist_add_boolean_array(nvlist_t *nvl, const char *name,
216 boolean_t *val, uint_t n)
217{
c99c9001 218 VERIFY0(nvlist_add_boolean_array(nvl, name, val, n));
9ae529ec
CS		 219}
220
221void
222fnvlist_add_byte_array(nvlist_t *nvl, const char *name, uchar_t *val, uint_t n)
223{
c99c9001 224 VERIFY0(nvlist_add_byte_array(nvl, name, val, n));
9ae529ec
CS		 225}
226
227void
228fnvlist_add_int8_array(nvlist_t *nvl, const char *name, int8_t *val, uint_t n)
229{
c99c9001 230 VERIFY0(nvlist_add_int8_array(nvl, name, val, n));
9ae529ec
CS		 231}
232
233void
234fnvlist_add_uint8_array(nvlist_t *nvl, const char *name, uint8_t *val, uint_t n)
235{
c99c9001 236 VERIFY0(nvlist_add_uint8_array(nvl, name, val, n));
9ae529ec
CS		 237}
238
239void
240fnvlist_add_int16_array(nvlist_t *nvl, const char *name, int16_t *val, uint_t n)
241{
c99c9001 242 VERIFY0(nvlist_add_int16_array(nvl, name, val, n));
9ae529ec
CS		 243}
244
245void
246fnvlist_add_uint16_array(nvlist_t *nvl, const char *name,
247 uint16_t *val, uint_t n)
248{
c99c9001 249 VERIFY0(nvlist_add_uint16_array(nvl, name, val, n));
9ae529ec
CS		 250}
251
252void
253fnvlist_add_int32_array(nvlist_t *nvl, const char *name, int32_t *val, uint_t n)
254{
c99c9001 255 VERIFY0(nvlist_add_int32_array(nvl, name, val, n));
9ae529ec
CS		 256}
257
258void
259fnvlist_add_uint32_array(nvlist_t *nvl, const char *name,
260 uint32_t *val, uint_t n)
261{
c99c9001 262 VERIFY0(nvlist_add_uint32_array(nvl, name, val, n));
9ae529ec
CS		 263}
264
265void
266fnvlist_add_int64_array(nvlist_t *nvl, const char *name, int64_t *val, uint_t n)
267{
c99c9001 268 VERIFY0(nvlist_add_int64_array(nvl, name, val, n));
9ae529ec
CS		 269}
270
271void
272fnvlist_add_uint64_array(nvlist_t *nvl, const char *name,
273 uint64_t *val, uint_t n)
274{
c99c9001 275 VERIFY0(nvlist_add_uint64_array(nvl, name, val, n));
9ae529ec
CS		 276}
277
278void
279fnvlist_add_string_array(nvlist_t *nvl, const char *name,
280 char * const *val, uint_t n)
281{
c99c9001 282 VERIFY0(nvlist_add_string_array(nvl, name, val, n));
9ae529ec
CS		 283}
284
285void
286fnvlist_add_nvlist_array(nvlist_t *nvl, const char *name,
287 nvlist_t **val, uint_t n)
288{
c99c9001 289 VERIFY0(nvlist_add_nvlist_array(nvl, name, val, n));
9ae529ec
CS		 290}
291
292void
293fnvlist_remove(nvlist_t *nvl, const char *name)
294{
c99c9001 295 VERIFY0(nvlist_remove_all(nvl, name));
9ae529ec
CS		 296}
297
298void
299fnvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *pair)
300{
c99c9001 301 VERIFY0(nvlist_remove_nvpair(nvl, pair));
9ae529ec
CS		 302}
303
304nvpair_t *
305fnvlist_lookup_nvpair(nvlist_t *nvl, const char *name)
306{
307 nvpair_t *rv;
c99c9001 308 VERIFY0(nvlist_lookup_nvpair(nvl, name, &rv));
9ae529ec
CS		 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;
c99c9001 323 VERIFY0(nvlist_lookup_boolean_value(nvl, name, &rv));
9ae529ec
CS		 324 return (rv);
325}
326
327uchar_t
328fnvlist_lookup_byte(nvlist_t *nvl, const char *name)
329{
330 uchar_t rv;
c99c9001 331 VERIFY0(nvlist_lookup_byte(nvl, name, &rv));
9ae529ec
CS		 332 return (rv);
333}
334
335int8_t
336fnvlist_lookup_int8(nvlist_t *nvl, const char *name)
337{
338 int8_t rv;
c99c9001 339 VERIFY0(nvlist_lookup_int8(nvl, name, &rv));
9ae529ec
CS		 340 return (rv);
341}
342
343int16_t
344fnvlist_lookup_int16(nvlist_t *nvl, const char *name)
345{
346 int16_t rv;
c99c9001 347 VERIFY0(nvlist_lookup_int16(nvl, name, &rv));
9ae529ec
CS		 348 return (rv);
349}
350
351int32_t
352fnvlist_lookup_int32(nvlist_t *nvl, const char *name)
353{
354 int32_t rv;
c99c9001 355 VERIFY0(nvlist_lookup_int32(nvl, name, &rv));
9ae529ec
CS		 356 return (rv);
357}
358
359int64_t
360fnvlist_lookup_int64(nvlist_t *nvl, const char *name)
361{
362 int64_t rv;
c99c9001 363 VERIFY0(nvlist_lookup_int64(nvl, name, &rv));
9ae529ec
CS		 364 return (rv);
365}
366
367uint8_t
368fnvlist_lookup_uint8(nvlist_t *nvl, const char *name)
369{
370 uint8_t rv;
c99c9001 371 VERIFY0(nvlist_lookup_uint8(nvl, name, &rv));
9ae529ec
CS		 372 return (rv);
373}
374
375uint16_t
376fnvlist_lookup_uint16(nvlist_t *nvl, const char *name)
377{
378 uint16_t rv;
c99c9001 379 VERIFY0(nvlist_lookup_uint16(nvl, name, &rv));
9ae529ec
CS		 380 return (rv);
381}
382
383uint32_t
384fnvlist_lookup_uint32(nvlist_t *nvl, const char *name)
385{
386 uint32_t rv;
c99c9001 387 VERIFY0(nvlist_lookup_uint32(nvl, name, &rv));
9ae529ec
CS		 388 return (rv);
389}
390
391uint64_t
392fnvlist_lookup_uint64(nvlist_t *nvl, const char *name)
393{
394 uint64_t rv;
c99c9001 395 VERIFY0(nvlist_lookup_uint64(nvl, name, &rv));
9ae529ec
CS		 396 return (rv);
397}
398
399char *
400fnvlist_lookup_string(nvlist_t *nvl, const char *name)
401{
402 char *rv;
c99c9001 403 VERIFY0(nvlist_lookup_string(nvl, name, &rv));
9ae529ec
CS		 404 return (rv);
405}
406
407nvlist_t *
408fnvlist_lookup_nvlist(nvlist_t *nvl, const char *name)
409{
410 nvlist_t *rv;
c99c9001 411 VERIFY0(nvlist_lookup_nvlist(nvl, name, &rv));
9ae529ec
CS		 412 return (rv);
413}
95542372
PD		 414boolean_t *
415fnvlist_lookup_boolean_array(nvlist_t *nvl, const char *name, uint_t *n)
416{
417 boolean_t *rv;
418 VERIFY0(nvlist_lookup_boolean_array(nvl, name, &rv, n));
419 return (rv);
420}
421
422uchar_t *
423fnvlist_lookup_byte_array(nvlist_t *nvl, const char *name, uint_t *n)
424{
425 uchar_t *rv;
426 VERIFY0(nvlist_lookup_byte_array(nvl, name, &rv, n));
427 return (rv);
428}
429
430int8_t *
431fnvlist_lookup_int8_array(nvlist_t *nvl, const char *name, uint_t *n)
432{
433 int8_t *rv;
434 VERIFY0(nvlist_lookup_int8_array(nvl, name, &rv, n));
435 return (rv);
436}
437
438uint8_t *
439fnvlist_lookup_uint8_array(nvlist_t *nvl, const char *name, uint_t *n)
440{
441 uint8_t *rv;
442 VERIFY0(nvlist_lookup_uint8_array(nvl, name, &rv, n));
443 return (rv);
444}
445
446int16_t *
447fnvlist_lookup_int16_array(nvlist_t *nvl, const char *name, uint_t *n)
448{
449 int16_t *rv;
450 VERIFY0(nvlist_lookup_int16_array(nvl, name, &rv, n));
451 return (rv);
452}
453
454uint16_t *
455fnvlist_lookup_uint16_array(nvlist_t *nvl, const char *name, uint_t *n)
456{
457 uint16_t *rv;
458 VERIFY0(nvlist_lookup_uint16_array(nvl, name, &rv, n));
459 return (rv);
460}
461
462int32_t *
463fnvlist_lookup_int32_array(nvlist_t *nvl, const char *name, uint_t *n)
464{
465 int32_t *rv;
466 VERIFY0(nvlist_lookup_int32_array(nvl, name, &rv, n));
467 return (rv);
468}
469
470uint32_t *
471fnvlist_lookup_uint32_array(nvlist_t *nvl, const char *name, uint_t *n)
472{
473 uint32_t *rv;
474 VERIFY0(nvlist_lookup_uint32_array(nvl, name, &rv, n));
475 return (rv);
476}
477
478int64_t *
479fnvlist_lookup_int64_array(nvlist_t *nvl, const char *name, uint_t *n)
480{
481 int64_t *rv;
482 VERIFY0(nvlist_lookup_int64_array(nvl, name, &rv, n));
483 return (rv);
484}
485
486uint64_t *
487fnvlist_lookup_uint64_array(nvlist_t *nvl, const char *name, uint_t *n)
488{
489 uint64_t *rv;
490 VERIFY0(nvlist_lookup_uint64_array(nvl, name, &rv, n));
491 return (rv);
492}
9ae529ec
CS		 493
494boolean_t
495fnvpair_value_boolean_value(nvpair_t *nvp)
496{
497 boolean_t rv;
c99c9001 498 VERIFY0(nvpair_value_boolean_value(nvp, &rv));
9ae529ec
CS		 499 return (rv);
500}
501
502uchar_t
503fnvpair_value_byte(nvpair_t *nvp)
504{
505 uchar_t rv;
c99c9001 506 VERIFY0(nvpair_value_byte(nvp, &rv));
9ae529ec
CS		 507 return (rv);
508}
509
510int8_t
511fnvpair_value_int8(nvpair_t *nvp)
512{
513 int8_t rv;
c99c9001 514 VERIFY0(nvpair_value_int8(nvp, &rv));
9ae529ec
CS		 515 return (rv);
516}
517
518int16_t
519fnvpair_value_int16(nvpair_t *nvp)
520{
521 int16_t rv;
c99c9001 522 VERIFY0(nvpair_value_int16(nvp, &rv));
9ae529ec
CS		 523 return (rv);
524}
525
526int32_t
527fnvpair_value_int32(nvpair_t *nvp)
528{
529 int32_t rv;
c99c9001 530 VERIFY0(nvpair_value_int32(nvp, &rv));
9ae529ec
CS		 531 return (rv);
532}
533
534int64_t
535fnvpair_value_int64(nvpair_t *nvp)
536{
537 int64_t rv;
c99c9001 538 VERIFY0(nvpair_value_int64(nvp, &rv));
9ae529ec
CS		 539 return (rv);
540}
541
542uint8_t
543fnvpair_value_uint8(nvpair_t *nvp)
544{
545 uint8_t rv;
c99c9001 546 VERIFY0(nvpair_value_uint8(nvp, &rv));
9ae529ec
CS		 547 return (rv);
548}
549
550uint16_t
551fnvpair_value_uint16(nvpair_t *nvp)
552{
553 uint16_t rv;
c99c9001 554 VERIFY0(nvpair_value_uint16(nvp, &rv));
9ae529ec
CS		 555 return (rv);
556}
557
558uint32_t
559fnvpair_value_uint32(nvpair_t *nvp)
560{
561 uint32_t rv;
c99c9001 562 VERIFY0(nvpair_value_uint32(nvp, &rv));
9ae529ec
CS		 563 return (rv);
564}
565
566uint64_t
567fnvpair_value_uint64(nvpair_t *nvp)
568{
569 uint64_t rv;
c99c9001 570 VERIFY0(nvpair_value_uint64(nvp, &rv));
9ae529ec
CS		 571 return (rv);
572}
573
574char *
575fnvpair_value_string(nvpair_t *nvp)
576{
577 char *rv;
c99c9001 578 VERIFY0(nvpair_value_string(nvp, &rv));
9ae529ec
CS		 579 return (rv);
580}
581
582nvlist_t *
583fnvpair_value_nvlist(nvpair_t *nvp)
584{
585 nvlist_t *rv;
c99c9001 586 VERIFY0(nvpair_value_nvlist(nvp, &rv));
9ae529ec
CS		 587 return (rv);
588}
589
93ce2b4c 590#if defined(_KERNEL)
9ae529ec
CS		 591
592EXPORT_SYMBOL(fnvlist_alloc);
593EXPORT_SYMBOL(fnvlist_free);
594EXPORT_SYMBOL(fnvlist_size);
595EXPORT_SYMBOL(fnvlist_pack);
6f1ffb06 596EXPORT_SYMBOL(fnvlist_pack_free);
9ae529ec
CS		 597EXPORT_SYMBOL(fnvlist_unpack);
598EXPORT_SYMBOL(fnvlist_dup);
599EXPORT_SYMBOL(fnvlist_merge);
600
601EXPORT_SYMBOL(fnvlist_add_nvpair);
602EXPORT_SYMBOL(fnvlist_add_boolean);
603EXPORT_SYMBOL(fnvlist_add_boolean_value);
604EXPORT_SYMBOL(fnvlist_add_byte);
605EXPORT_SYMBOL(fnvlist_add_int8);
606EXPORT_SYMBOL(fnvlist_add_uint8);
607EXPORT_SYMBOL(fnvlist_add_int16);
608EXPORT_SYMBOL(fnvlist_add_uint16);
609EXPORT_SYMBOL(fnvlist_add_int32);
610EXPORT_SYMBOL(fnvlist_add_uint32);
611EXPORT_SYMBOL(fnvlist_add_int64);
612EXPORT_SYMBOL(fnvlist_add_uint64);
613EXPORT_SYMBOL(fnvlist_add_string);
614EXPORT_SYMBOL(fnvlist_add_nvlist);
615EXPORT_SYMBOL(fnvlist_add_boolean_array);
616EXPORT_SYMBOL(fnvlist_add_byte_array);
617EXPORT_SYMBOL(fnvlist_add_int8_array);
618EXPORT_SYMBOL(fnvlist_add_uint8_array);
619EXPORT_SYMBOL(fnvlist_add_int16_array);
620EXPORT_SYMBOL(fnvlist_add_uint16_array);
621EXPORT_SYMBOL(fnvlist_add_int32_array);
622EXPORT_SYMBOL(fnvlist_add_uint32_array);
623EXPORT_SYMBOL(fnvlist_add_int64_array);
624EXPORT_SYMBOL(fnvlist_add_uint64_array);
625EXPORT_SYMBOL(fnvlist_add_string_array);
626EXPORT_SYMBOL(fnvlist_add_nvlist_array);
627
628EXPORT_SYMBOL(fnvlist_remove);
629EXPORT_SYMBOL(fnvlist_remove_nvpair);
630
631EXPORT_SYMBOL(fnvlist_lookup_nvpair);
632EXPORT_SYMBOL(fnvlist_lookup_boolean);
633EXPORT_SYMBOL(fnvlist_lookup_boolean_value);
634EXPORT_SYMBOL(fnvlist_lookup_byte);
635EXPORT_SYMBOL(fnvlist_lookup_int8);
636EXPORT_SYMBOL(fnvlist_lookup_uint8);
637EXPORT_SYMBOL(fnvlist_lookup_int16);
638EXPORT_SYMBOL(fnvlist_lookup_uint16);
639EXPORT_SYMBOL(fnvlist_lookup_int32);
640EXPORT_SYMBOL(fnvlist_lookup_uint32);
641EXPORT_SYMBOL(fnvlist_lookup_int64);
642EXPORT_SYMBOL(fnvlist_lookup_uint64);
643EXPORT_SYMBOL(fnvlist_lookup_string);
644EXPORT_SYMBOL(fnvlist_lookup_nvlist);
645
646EXPORT_SYMBOL(fnvpair_value_boolean_value);
647EXPORT_SYMBOL(fnvpair_value_byte);
648EXPORT_SYMBOL(fnvpair_value_int8);
649EXPORT_SYMBOL(fnvpair_value_uint8);
650EXPORT_SYMBOL(fnvpair_value_int16);
651EXPORT_SYMBOL(fnvpair_value_uint16);
652EXPORT_SYMBOL(fnvpair_value_int32);
653EXPORT_SYMBOL(fnvpair_value_uint32);
654EXPORT_SYMBOL(fnvpair_value_int64);
655EXPORT_SYMBOL(fnvpair_value_uint64);
656EXPORT_SYMBOL(fnvpair_value_string);
657EXPORT_SYMBOL(fnvpair_value_nvlist);
13fe0198 658EXPORT_SYMBOL(fnvlist_num_pairs);
9ae529ec
CS		 659
660#endif
ZFS On Linux mirror for PVE