mirror of
https://git.proxmox.com/git/mirror_zfs.git
synced 2026-05-22 02:27:36 +03:00
2619 asynchronous destruction of ZFS file systems 2747 SPA versioning with zfs feature flags Reviewed by: Matt Ahrens <mahrens@delphix.com> Reviewed by: George Wilson <gwilson@delphix.com> Reviewed by: Richard Lowe <richlowe@richlowe.net> Reviewed by: Dan Kruchinin <dan.kruchinin@gmail.com> Approved by: Eric Schrock <Eric.Schrock@delphix.com> References: illumos/illumos-gate@53089ab7c8 illumos/illumos-gate@ad135b5d64 illumos changeset: 13700:2889e2596bd6 https://www.illumos.org/issues/2619 https://www.illumos.org/issues/2747 NOTE: The grub specific changes were not ported. This change must be made to the Linux grub packages. Ported-by: Brian Behlendorf <behlendorf1@llnl.gov>
This commit is contained in:
Christopher Siden
committed by
Brian Behlendorf
Brian Behlendorf
parent
15313c5e18
commit
9ae529ec5d
@@ -5,5 +5,6 @@ EXTRA_CFLAGS = $(ZFS_MODULE_CFLAGS) @KERNELCPPFLAGS@
|
||||
obj-$(CONFIG_ZFS) := $(MODULE).o
|
||||
|
||||
$(MODULE)-objs += @top_srcdir@/module/nvpair/nvpair.o
|
||||
$(MODULE)-objs += @top_srcdir@/module/nvpair/fnvpair.o
|
||||
$(MODULE)-objs += @top_srcdir@/module/nvpair/nvpair_alloc_spl.o
|
||||
$(MODULE)-objs += @top_srcdir@/module/nvpair/nvpair_alloc_fixed.o
|
||||
|
||||
@@ -0,0 +1,566 @@
|
||||
/*
|
||||
* CDDL HEADER START
|
||||
*
|
||||
* The contents of this file are subject to the terms of the
|
||||
* Common Development and Distribution License (the "License").
|
||||
* You may not use this file except in compliance with the License.
|
||||
*
|
||||
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
|
||||
* or http://www.opensolaris.org/os/licensing.
|
||||
* See the License for the specific language governing permissions
|
||||
* and limitations under the License.
|
||||
*
|
||||
* When distributing Covered Code, include this CDDL HEADER in each
|
||||
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
||||
* If applicable, add the following below this CDDL HEADER, with the
|
||||
* fields enclosed by brackets "[]" replaced with your own identifying
|
||||
* information: Portions Copyright [yyyy] [name of copyright owner]
|
||||
*
|
||||
* CDDL HEADER END
|
||||
*/
|
||||
|
||||
/*
|
||||
* Copyright (c) 2012 by Delphix. All rights reserved.
|
||||
*/
|
||||
|
||||
#include <sys/nvpair.h>
|
||||
#include <sys/kmem.h>
|
||||
#include <sys/debug.h>
|
||||
#ifndef _KERNEL
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
/*
|
||||
* "Force" nvlist wrapper.
|
||||
*
|
||||
* These functions wrap the nvlist_* functions with assertions that assume
|
||||
* the operation is successful. This allows the caller's code to be much
|
||||
* more readable, especially for the fnvlist_lookup_* and fnvpair_value_*
|
||||
* functions, which can return the requested value (rather than filling in
|
||||
* a pointer).
|
||||
*
|
||||
* These functions use NV_UNIQUE_NAME, encoding NV_ENCODE_NATIVE, and allocate
|
||||
* with KM_SLEEP.
|
||||
*
|
||||
* More wrappers should be added as needed -- for example
|
||||
* nvlist_lookup_*_array and nvpair_value_*_array.
|
||||
*/
|
||||
|
||||
nvlist_t *
|
||||
fnvlist_alloc(void)
|
||||
{
|
||||
nvlist_t *nvl;
|
||||
VERIFY3U(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP), ==, 0);
|
||||
return (nvl);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_free(nvlist_t *nvl)
|
||||
{
|
||||
nvlist_free(nvl);
|
||||
}
|
||||
|
||||
size_t
|
||||
fnvlist_size(nvlist_t *nvl)
|
||||
{
|
||||
size_t size;
|
||||
VERIFY3U(nvlist_size(nvl, &size, NV_ENCODE_NATIVE), ==, 0);
|
||||
return (size);
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns allocated buffer of size *sizep. Caller must free the buffer with
|
||||
* fnvlist_pack_free().
|
||||
*/
|
||||
char *
|
||||
fnvlist_pack(nvlist_t *nvl, size_t *sizep)
|
||||
{
|
||||
char *packed = 0;
|
||||
VERIFY3U(nvlist_pack(nvl, &packed, sizep, NV_ENCODE_NATIVE,
|
||||
KM_SLEEP), ==, 0);
|
||||
return (packed);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
void
|
||||
fnvlist_pack_free(char *pack, size_t size)
|
||||
{
|
||||
#ifdef _KERNEL
|
||||
kmem_free(pack, size);
|
||||
#else
|
||||
free(pack);
|
||||
#endif
|
||||
}
|
||||
|
||||
nvlist_t *
|
||||
fnvlist_unpack(char *buf, size_t buflen)
|
||||
{
|
||||
nvlist_t *rv;
|
||||
VERIFY3U(nvlist_unpack(buf, buflen, &rv, KM_SLEEP), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
nvlist_t *
|
||||
fnvlist_dup(nvlist_t *nvl)
|
||||
{
|
||||
nvlist_t *rv;
|
||||
VERIFY3U(nvlist_dup(nvl, &rv, KM_SLEEP), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_merge(nvlist_t *dst, nvlist_t *src)
|
||||
{
|
||||
VERIFY3U(nvlist_merge(dst, src, KM_SLEEP), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_boolean(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
VERIFY3U(nvlist_add_boolean(nvl, name), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_boolean_value(nvlist_t *nvl, const char *name, boolean_t val)
|
||||
{
|
||||
VERIFY3U(nvlist_add_boolean_value(nvl, name, val), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_byte(nvlist_t *nvl, const char *name, uchar_t val)
|
||||
{
|
||||
VERIFY3U(nvlist_add_byte(nvl, name, val), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_int8(nvlist_t *nvl, const char *name, int8_t val)
|
||||
{
|
||||
VERIFY3U(nvlist_add_int8(nvl, name, val), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_uint8(nvlist_t *nvl, const char *name, uint8_t val)
|
||||
{
|
||||
VERIFY3U(nvlist_add_uint8(nvl, name, val), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_int16(nvlist_t *nvl, const char *name, int16_t val)
|
||||
{
|
||||
VERIFY3U(nvlist_add_int16(nvl, name, val), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_uint16(nvlist_t *nvl, const char *name, uint16_t val)
|
||||
{
|
||||
VERIFY3U(nvlist_add_uint16(nvl, name, val), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_int32(nvlist_t *nvl, const char *name, int32_t val)
|
||||
{
|
||||
VERIFY3U(nvlist_add_int32(nvl, name, val), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val)
|
||||
{
|
||||
VERIFY3U(nvlist_add_uint32(nvl, name, val), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_int64(nvlist_t *nvl, const char *name, int64_t val)
|
||||
{
|
||||
VERIFY3U(nvlist_add_int64(nvl, name, val), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_uint64(nvlist_t *nvl, const char *name, uint64_t val)
|
||||
{
|
||||
VERIFY3U(nvlist_add_uint64(nvl, name, val), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_string(nvlist_t *nvl, const char *name, const char *val)
|
||||
{
|
||||
VERIFY3U(nvlist_add_string(nvl, name, val), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val)
|
||||
{
|
||||
VERIFY3U(nvlist_add_nvlist(nvl, name, val), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_nvpair(nvlist_t *nvl, nvpair_t *pair)
|
||||
{
|
||||
VERIFY3U(nvlist_add_nvpair(nvl, pair), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_boolean_array(nvlist_t *nvl, const char *name,
|
||||
boolean_t *val, uint_t n)
|
||||
{
|
||||
VERIFY3U(nvlist_add_boolean_array(nvl, name, val, n), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_byte_array(nvlist_t *nvl, const char *name, uchar_t *val, uint_t n)
|
||||
{
|
||||
VERIFY3U(nvlist_add_byte_array(nvl, name, val, n), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_int8_array(nvlist_t *nvl, const char *name, int8_t *val, uint_t n)
|
||||
{
|
||||
VERIFY3U(nvlist_add_int8_array(nvl, name, val, n), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_uint8_array(nvlist_t *nvl, const char *name, uint8_t *val, uint_t n)
|
||||
{
|
||||
VERIFY3U(nvlist_add_uint8_array(nvl, name, val, n), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_int16_array(nvlist_t *nvl, const char *name, int16_t *val, uint_t n)
|
||||
{
|
||||
VERIFY3U(nvlist_add_int16_array(nvl, name, val, n), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_uint16_array(nvlist_t *nvl, const char *name,
|
||||
uint16_t *val, uint_t n)
|
||||
{
|
||||
VERIFY3U(nvlist_add_uint16_array(nvl, name, val, n), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_int32_array(nvlist_t *nvl, const char *name, int32_t *val, uint_t n)
|
||||
{
|
||||
VERIFY3U(nvlist_add_int32_array(nvl, name, val, n), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_uint32_array(nvlist_t *nvl, const char *name,
|
||||
uint32_t *val, uint_t n)
|
||||
{
|
||||
VERIFY3U(nvlist_add_uint32_array(nvl, name, val, n), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_int64_array(nvlist_t *nvl, const char *name, int64_t *val, uint_t n)
|
||||
{
|
||||
VERIFY3U(nvlist_add_int64_array(nvl, name, val, n), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_uint64_array(nvlist_t *nvl, const char *name,
|
||||
uint64_t *val, uint_t n)
|
||||
{
|
||||
VERIFY3U(nvlist_add_uint64_array(nvl, name, val, n), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_string_array(nvlist_t *nvl, const char *name,
|
||||
char * const *val, uint_t n)
|
||||
{
|
||||
VERIFY3U(nvlist_add_string_array(nvl, name, val, n), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_add_nvlist_array(nvlist_t *nvl, const char *name,
|
||||
nvlist_t **val, uint_t n)
|
||||
{
|
||||
VERIFY3U(nvlist_add_nvlist_array(nvl, name, val, n), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_remove(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
VERIFY3U(nvlist_remove_all(nvl, name), ==, 0);
|
||||
}
|
||||
|
||||
void
|
||||
fnvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *pair)
|
||||
{
|
||||
VERIFY3U(nvlist_remove_nvpair(nvl, pair), ==, 0);
|
||||
}
|
||||
|
||||
nvpair_t *
|
||||
fnvlist_lookup_nvpair(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
nvpair_t *rv;
|
||||
VERIFY3U(nvlist_lookup_nvpair(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
/* returns B_TRUE if the entry exists */
|
||||
boolean_t
|
||||
fnvlist_lookup_boolean(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
return (nvlist_lookup_boolean(nvl, name) == 0);
|
||||
}
|
||||
|
||||
boolean_t
|
||||
fnvlist_lookup_boolean_value(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
boolean_t rv;
|
||||
VERIFY3U(nvlist_lookup_boolean_value(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
uchar_t
|
||||
fnvlist_lookup_byte(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
uchar_t rv;
|
||||
VERIFY3U(nvlist_lookup_byte(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int8_t
|
||||
fnvlist_lookup_int8(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
int8_t rv;
|
||||
VERIFY3U(nvlist_lookup_int8(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int16_t
|
||||
fnvlist_lookup_int16(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
int16_t rv;
|
||||
VERIFY3U(nvlist_lookup_int16(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int32_t
|
||||
fnvlist_lookup_int32(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
int32_t rv;
|
||||
VERIFY3U(nvlist_lookup_int32(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int64_t
|
||||
fnvlist_lookup_int64(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
int64_t rv;
|
||||
VERIFY3U(nvlist_lookup_int64(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
uint8_t
|
||||
fnvlist_lookup_uint8(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
uint8_t rv;
|
||||
VERIFY3U(nvlist_lookup_uint8(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
uint16_t
|
||||
fnvlist_lookup_uint16(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
uint16_t rv;
|
||||
VERIFY3U(nvlist_lookup_uint16(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
uint32_t
|
||||
fnvlist_lookup_uint32(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
uint32_t rv;
|
||||
VERIFY3U(nvlist_lookup_uint32(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
uint64_t
|
||||
fnvlist_lookup_uint64(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
uint64_t rv;
|
||||
VERIFY3U(nvlist_lookup_uint64(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
char *
|
||||
fnvlist_lookup_string(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
char *rv;
|
||||
VERIFY3U(nvlist_lookup_string(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
nvlist_t *
|
||||
fnvlist_lookup_nvlist(nvlist_t *nvl, const char *name)
|
||||
{
|
||||
nvlist_t *rv;
|
||||
VERIFY3U(nvlist_lookup_nvlist(nvl, name, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
boolean_t
|
||||
fnvpair_value_boolean_value(nvpair_t *nvp)
|
||||
{
|
||||
boolean_t rv;
|
||||
VERIFY3U(nvpair_value_boolean_value(nvp, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
uchar_t
|
||||
fnvpair_value_byte(nvpair_t *nvp)
|
||||
{
|
||||
uchar_t rv;
|
||||
VERIFY3U(nvpair_value_byte(nvp, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int8_t
|
||||
fnvpair_value_int8(nvpair_t *nvp)
|
||||
{
|
||||
int8_t rv;
|
||||
VERIFY3U(nvpair_value_int8(nvp, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int16_t
|
||||
fnvpair_value_int16(nvpair_t *nvp)
|
||||
{
|
||||
int16_t rv;
|
||||
VERIFY3U(nvpair_value_int16(nvp, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int32_t
|
||||
fnvpair_value_int32(nvpair_t *nvp)
|
||||
{
|
||||
int32_t rv;
|
||||
VERIFY3U(nvpair_value_int32(nvp, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int64_t
|
||||
fnvpair_value_int64(nvpair_t *nvp)
|
||||
{
|
||||
int64_t rv;
|
||||
VERIFY3U(nvpair_value_int64(nvp, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
uint8_t
|
||||
fnvpair_value_uint8(nvpair_t *nvp)
|
||||
{
|
||||
uint8_t rv;
|
||||
VERIFY3U(nvpair_value_uint8(nvp, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
uint16_t
|
||||
fnvpair_value_uint16(nvpair_t *nvp)
|
||||
{
|
||||
uint16_t rv;
|
||||
VERIFY3U(nvpair_value_uint16(nvp, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
uint32_t
|
||||
fnvpair_value_uint32(nvpair_t *nvp)
|
||||
{
|
||||
uint32_t rv;
|
||||
VERIFY3U(nvpair_value_uint32(nvp, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
uint64_t
|
||||
fnvpair_value_uint64(nvpair_t *nvp)
|
||||
{
|
||||
uint64_t rv;
|
||||
VERIFY3U(nvpair_value_uint64(nvp, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
char *
|
||||
fnvpair_value_string(nvpair_t *nvp)
|
||||
{
|
||||
char *rv;
|
||||
VERIFY3U(nvpair_value_string(nvp, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
nvlist_t *
|
||||
fnvpair_value_nvlist(nvpair_t *nvp)
|
||||
{
|
||||
nvlist_t *rv;
|
||||
VERIFY3U(nvpair_value_nvlist(nvp, &rv), ==, 0);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
#if defined(_KERNEL) && defined(HAVE_SPL)
|
||||
|
||||
EXPORT_SYMBOL(fnvlist_alloc);
|
||||
EXPORT_SYMBOL(fnvlist_free);
|
||||
EXPORT_SYMBOL(fnvlist_size);
|
||||
EXPORT_SYMBOL(fnvlist_pack);
|
||||
EXPORT_SYMBOL(fnvlist_unpack);
|
||||
EXPORT_SYMBOL(fnvlist_dup);
|
||||
EXPORT_SYMBOL(fnvlist_merge);
|
||||
|
||||
EXPORT_SYMBOL(fnvlist_add_nvpair);
|
||||
EXPORT_SYMBOL(fnvlist_add_boolean);
|
||||
EXPORT_SYMBOL(fnvlist_add_boolean_value);
|
||||
EXPORT_SYMBOL(fnvlist_add_byte);
|
||||
EXPORT_SYMBOL(fnvlist_add_int8);
|
||||
EXPORT_SYMBOL(fnvlist_add_uint8);
|
||||
EXPORT_SYMBOL(fnvlist_add_int16);
|
||||
EXPORT_SYMBOL(fnvlist_add_uint16);
|
||||
EXPORT_SYMBOL(fnvlist_add_int32);
|
||||
EXPORT_SYMBOL(fnvlist_add_uint32);
|
||||
EXPORT_SYMBOL(fnvlist_add_int64);
|
||||
EXPORT_SYMBOL(fnvlist_add_uint64);
|
||||
EXPORT_SYMBOL(fnvlist_add_string);
|
||||
EXPORT_SYMBOL(fnvlist_add_nvlist);
|
||||
EXPORT_SYMBOL(fnvlist_add_boolean_array);
|
||||
EXPORT_SYMBOL(fnvlist_add_byte_array);
|
||||
EXPORT_SYMBOL(fnvlist_add_int8_array);
|
||||
EXPORT_SYMBOL(fnvlist_add_uint8_array);
|
||||
EXPORT_SYMBOL(fnvlist_add_int16_array);
|
||||
EXPORT_SYMBOL(fnvlist_add_uint16_array);
|
||||
EXPORT_SYMBOL(fnvlist_add_int32_array);
|
||||
EXPORT_SYMBOL(fnvlist_add_uint32_array);
|
||||
EXPORT_SYMBOL(fnvlist_add_int64_array);
|
||||
EXPORT_SYMBOL(fnvlist_add_uint64_array);
|
||||
EXPORT_SYMBOL(fnvlist_add_string_array);
|
||||
EXPORT_SYMBOL(fnvlist_add_nvlist_array);
|
||||
|
||||
EXPORT_SYMBOL(fnvlist_remove);
|
||||
EXPORT_SYMBOL(fnvlist_remove_nvpair);
|
||||
|
||||
EXPORT_SYMBOL(fnvlist_lookup_nvpair);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_boolean);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_boolean_value);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_byte);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_int8);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_uint8);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_int16);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_uint16);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_int32);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_uint32);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_int64);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_uint64);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_string);
|
||||
EXPORT_SYMBOL(fnvlist_lookup_nvlist);
|
||||
|
||||
EXPORT_SYMBOL(fnvpair_value_boolean_value);
|
||||
EXPORT_SYMBOL(fnvpair_value_byte);
|
||||
EXPORT_SYMBOL(fnvpair_value_int8);
|
||||
EXPORT_SYMBOL(fnvpair_value_uint8);
|
||||
EXPORT_SYMBOL(fnvpair_value_int16);
|
||||
EXPORT_SYMBOL(fnvpair_value_uint16);
|
||||
EXPORT_SYMBOL(fnvpair_value_int32);
|
||||
EXPORT_SYMBOL(fnvpair_value_uint32);
|
||||
EXPORT_SYMBOL(fnvpair_value_int64);
|
||||
EXPORT_SYMBOL(fnvpair_value_uint64);
|
||||
EXPORT_SYMBOL(fnvpair_value_string);
|
||||
EXPORT_SYMBOL(fnvpair_value_nvlist);
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user