Refresh linux-kernel-module

.topdeps

@@ -1,3 +1 @@
-gcc-branch
+zfs-branch
-fix-branch
-feature-branch

.topmsg

@@ -1,19 +1,11 @@
 From: Brian Behlendorf <behlendorf1@llnl.gov>
-Subject: [PATCH] zfs branch
+Subject: [PATCH] linux kernel module
 
-Merged result of all changes which are relevant to both Solaris
+Setup linux kernel module support, this includes:
-and Linux builds of the ZFS code.  These are changes where there
+- zfs context for kernel/user
-is a reasonable chance they will be accepted upstream.
+- kernel module build system integration
-
+- kernel module macros
-Additionally, since this is effectively the root of the linux
+- kernel module symbol export
-ZFS tree the core linux build system is added here.  This
+- kernel module options
-includes autogen.sh, configure.ac, m4 macros, some scripts/*,
-and makefiles for all the core ZFS components.  Linux-only
-features which require tweaks to the build system should appear
-on the relevant topic branches.  All autotools products which
-result from autogen.sh are commited to the linux-configure-branch.
-
-This branch also contains the META, ChangeLog, AUTHORS,
-README, and GIT files.
 
 Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>

zfs/lib/libavl/avl.c

@@ -1031,3 +1031,36 @@ done:
 
 	return (AVL_NODE2DATA(node, off));
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+static int __init avl_init(void)
+{
+	return 0;
+}
+
+static void avl_fini(void)
+{
+        return;
+}
+
+module_init(avl_init);
+module_exit(avl_fini);
+
+MODULE_AUTHOR("Sun Microsystems, Inc");
+MODULE_DESCRIPTION("Generic AVL tree implementation");
+MODULE_LICENSE("CDDL");
+
+EXPORT_SYMBOL(avl_create);
+EXPORT_SYMBOL(avl_find);
+EXPORT_SYMBOL(avl_insert);
+EXPORT_SYMBOL(avl_insert_here);
+EXPORT_SYMBOL(avl_walk);
+EXPORT_SYMBOL(avl_first);
+EXPORT_SYMBOL(avl_last);
+EXPORT_SYMBOL(avl_nearest);
+EXPORT_SYMBOL(avl_add);
+EXPORT_SYMBOL(avl_remove);
+EXPORT_SYMBOL(avl_numnodes);
+EXPORT_SYMBOL(avl_destroy_nodes);
+EXPORT_SYMBOL(avl_destroy);
+#endif

zfs/lib/libavl/zu.c

@@ -0,0 +1,4 @@
+int main(void)
+{
+	return 0;
+}

zfs/lib/libnvpair/nvpair.c

@@ -3244,3 +3244,134 @@ nvs_xdr(nvstream_t *nvs, nvlist_t *nvl, char *buf, size_t *buflen)
 
 	return (err);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+static int __init nvpair_init(void)
+{
+	        return 0;
+}
+
+static void nvpair_fini(void)
+{
+	        return;
+}
+
+module_init(nvpair_init);
+module_exit(nvpair_fini);
+
+MODULE_AUTHOR("Sun Microsystems, Inc");
+MODULE_DESCRIPTION("Generic name/value pair implementation");
+MODULE_LICENSE("CDDL");
+
+EXPORT_SYMBOL(nv_alloc_init);
+EXPORT_SYMBOL(nv_alloc_reset);
+EXPORT_SYMBOL(nv_alloc_fini);
+
+/* list management */
+EXPORT_SYMBOL(nvlist_alloc);
+EXPORT_SYMBOL(nvlist_free);
+EXPORT_SYMBOL(nvlist_size);
+EXPORT_SYMBOL(nvlist_pack);
+EXPORT_SYMBOL(nvlist_unpack);
+EXPORT_SYMBOL(nvlist_dup);
+EXPORT_SYMBOL(nvlist_merge);
+
+EXPORT_SYMBOL(nvlist_xalloc);
+EXPORT_SYMBOL(nvlist_xpack);
+EXPORT_SYMBOL(nvlist_xunpack);
+EXPORT_SYMBOL(nvlist_xdup);
+EXPORT_SYMBOL(nvlist_lookup_nv_alloc);
+
+EXPORT_SYMBOL(nvlist_add_nvpair);
+EXPORT_SYMBOL(nvlist_add_boolean);
+EXPORT_SYMBOL(nvlist_add_boolean_value);
+EXPORT_SYMBOL(nvlist_add_byte);
+EXPORT_SYMBOL(nvlist_add_int8);
+EXPORT_SYMBOL(nvlist_add_uint8);
+EXPORT_SYMBOL(nvlist_add_int16);
+EXPORT_SYMBOL(nvlist_add_uint16);
+EXPORT_SYMBOL(nvlist_add_int32);
+EXPORT_SYMBOL(nvlist_add_uint32);
+EXPORT_SYMBOL(nvlist_add_int64);
+EXPORT_SYMBOL(nvlist_add_uint64);
+EXPORT_SYMBOL(nvlist_add_string);
+EXPORT_SYMBOL(nvlist_add_nvlist);
+EXPORT_SYMBOL(nvlist_add_boolean_array);
+EXPORT_SYMBOL(nvlist_add_byte_array);
+EXPORT_SYMBOL(nvlist_add_int8_array);
+EXPORT_SYMBOL(nvlist_add_uint8_array);
+EXPORT_SYMBOL(nvlist_add_int16_array);
+EXPORT_SYMBOL(nvlist_add_uint16_array);
+EXPORT_SYMBOL(nvlist_add_int32_array);
+EXPORT_SYMBOL(nvlist_add_uint32_array);
+EXPORT_SYMBOL(nvlist_add_int64_array);
+EXPORT_SYMBOL(nvlist_add_uint64_array);
+EXPORT_SYMBOL(nvlist_add_string_array);
+EXPORT_SYMBOL(nvlist_add_nvlist_array);
+EXPORT_SYMBOL(nvlist_add_hrtime);
+
+EXPORT_SYMBOL(nvlist_remove);
+EXPORT_SYMBOL(nvlist_remove_all);
+
+EXPORT_SYMBOL(nvlist_lookup_boolean);
+EXPORT_SYMBOL(nvlist_lookup_boolean_value);
+EXPORT_SYMBOL(nvlist_lookup_byte);
+EXPORT_SYMBOL(nvlist_lookup_int8);
+EXPORT_SYMBOL(nvlist_lookup_uint8);
+EXPORT_SYMBOL(nvlist_lookup_int16);
+EXPORT_SYMBOL(nvlist_lookup_uint16);
+EXPORT_SYMBOL(nvlist_lookup_int32);
+EXPORT_SYMBOL(nvlist_lookup_uint32);
+EXPORT_SYMBOL(nvlist_lookup_int64);
+EXPORT_SYMBOL(nvlist_lookup_uint64);
+EXPORT_SYMBOL(nvlist_lookup_string);
+EXPORT_SYMBOL(nvlist_lookup_nvlist);
+EXPORT_SYMBOL(nvlist_lookup_boolean_array);
+EXPORT_SYMBOL(nvlist_lookup_byte_array);
+EXPORT_SYMBOL(nvlist_lookup_int8_array);
+EXPORT_SYMBOL(nvlist_lookup_uint8_array);
+EXPORT_SYMBOL(nvlist_lookup_int16_array);
+EXPORT_SYMBOL(nvlist_lookup_uint16_array);
+EXPORT_SYMBOL(nvlist_lookup_int32_array);
+EXPORT_SYMBOL(nvlist_lookup_uint32_array);
+EXPORT_SYMBOL(nvlist_lookup_int64_array);
+EXPORT_SYMBOL(nvlist_lookup_uint64_array);
+EXPORT_SYMBOL(nvlist_lookup_string_array);
+EXPORT_SYMBOL(nvlist_lookup_nvlist_array);
+EXPORT_SYMBOL(nvlist_lookup_hrtime);
+EXPORT_SYMBOL(nvlist_lookup_pairs);
+
+EXPORT_SYMBOL(nvlist_lookup_nvpair);
+EXPORT_SYMBOL(nvlist_exists);
+
+/* processing nvpair */
+EXPORT_SYMBOL(nvlist_next_nvpair);
+EXPORT_SYMBOL(nvpair_name);
+EXPORT_SYMBOL(nvpair_type);
+EXPORT_SYMBOL(nvpair_value_boolean_value);
+EXPORT_SYMBOL(nvpair_value_byte);
+EXPORT_SYMBOL(nvpair_value_int8);
+EXPORT_SYMBOL(nvpair_value_uint8);
+EXPORT_SYMBOL(nvpair_value_int16);
+EXPORT_SYMBOL(nvpair_value_uint16);
+EXPORT_SYMBOL(nvpair_value_int32);
+EXPORT_SYMBOL(nvpair_value_uint32);
+EXPORT_SYMBOL(nvpair_value_int64);
+EXPORT_SYMBOL(nvpair_value_uint64);
+EXPORT_SYMBOL(nvpair_value_string);
+EXPORT_SYMBOL(nvpair_value_nvlist);
+EXPORT_SYMBOL(nvpair_value_boolean_array);
+EXPORT_SYMBOL(nvpair_value_byte_array);
+EXPORT_SYMBOL(nvpair_value_int8_array);
+EXPORT_SYMBOL(nvpair_value_uint8_array);
+EXPORT_SYMBOL(nvpair_value_int16_array);
+EXPORT_SYMBOL(nvpair_value_uint16_array);
+EXPORT_SYMBOL(nvpair_value_int32_array);
+EXPORT_SYMBOL(nvpair_value_uint32_array);
+EXPORT_SYMBOL(nvpair_value_int64_array);
+EXPORT_SYMBOL(nvpair_value_uint64_array);
+EXPORT_SYMBOL(nvpair_value_string_array);
+EXPORT_SYMBOL(nvpair_value_nvlist_array);
+EXPORT_SYMBOL(nvpair_value_hrtime);
+
+#endif

zfs/lib/libnvpair/nvpair_alloc_spl.c

@@ -0,0 +1,75 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License, Version 1.0 only
+ * (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 2004 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#include <sys/nvpair.h>
+#include <sys/kmem.h>
+
+static void *
+nv_alloc_sleep_spl(nv_alloc_t *nva, size_t size)
+{
+	return (kmem_alloc(size, KM_SLEEP));
+}
+
+static void *
+nv_alloc_nosleep_spl(nv_alloc_t *nva, size_t size)
+{
+	return (kmem_alloc(size, KM_NOSLEEP));
+}
+
+static void
+nv_free_spl(nv_alloc_t *nva, void *buf, size_t size)
+{
+	kmem_free(buf, size);
+}
+
+const nv_alloc_ops_t spl_sleep_ops_def = {
+	NULL,                   /* nv_ao_init() */
+	NULL,                   /* nv_ao_fini() */
+	nv_alloc_sleep_spl,     /* nv_ao_alloc() */
+	nv_free_spl,            /* nv_ao_free() */
+	NULL                    /* nv_ao_reset() */
+};
+
+const nv_alloc_ops_t spl_nosleep_ops_def = {
+	NULL,                   /* nv_ao_init() */
+	NULL,                   /* nv_ao_fini() */
+	nv_alloc_nosleep_spl,   /* nv_ao_alloc() */
+	nv_free_spl,            /* nv_ao_free() */
+	NULL                    /* nv_ao_reset() */
+};
+
+nv_alloc_t nv_alloc_sleep_def = {
+	&spl_sleep_ops_def,
+	NULL
+};
+
+nv_alloc_t nv_alloc_nosleep_def = {
+	&spl_nosleep_ops_def,
+	NULL
+};
+
+nv_alloc_t *nv_alloc_sleep = &nv_alloc_sleep_def;
+nv_alloc_t *nv_alloc_nosleep = &nv_alloc_nosleep_def;

zfs/lib/libnvpair/zu.c

@@ -0,0 +1,4 @@
+int main(void)
+{
+	return 0;
+}

zfs/lib/libumem/zu.c

@@ -0,0 +1,4 @@
+int main(void)
+{
+       return 0;
+}

zfs/lib/libuutil/zu.c

@@ -0,0 +1,4 @@
+int main(void)
+{
+       return 0;
+}

zfs/lib/libzcommon/zfs_comutil.c

@@ -63,3 +63,7 @@ zfs_allocatable_devs(nvlist_t *nv)
 	}
 	return (B_FALSE);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(zfs_allocatable_devs);
+#endif

zfs/lib/libzcommon/zfs_deleg.c

@@ -232,3 +232,9 @@ zfs_deleg_whokey(char *attr, zfs_deleg_who_type_t type,
 		ASSERT(!"bad zfs_deleg_who_type_t");
 	}
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(zfs_deleg_verify_nvlist);
+EXPORT_SYMBOL(zfs_deleg_whokey);
+EXPORT_SYMBOL(zfs_deleg_canonicalize_perm);
+#endif

zfs/lib/libzcommon/zfs_namecheck.c

@@ -361,3 +361,10 @@ dataset_name_hidden(const char *name)
 
 	return (0);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(snapshot_namecheck);
+EXPORT_SYMBOL(pool_namecheck);
+EXPORT_SYMBOL(dataset_name_hidden);
+EXPORT_SYMBOL(dataset_namecheck);
+#endif

zfs/lib/libzcommon/zfs_prop.c

@@ -494,3 +494,24 @@ zfs_prop_align_right(zfs_prop_t prop)
 }
 
 #endif
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+/* zfs dataset property functions */
+EXPORT_SYMBOL(zfs_prop_init);
+EXPORT_SYMBOL(zfs_prop_get_type);
+EXPORT_SYMBOL(zfs_prop_delegatable);
+EXPORT_SYMBOL(zfs_prop_get_table);
+
+/* Dataset property functions shared between libzfs and kernel. */
+EXPORT_SYMBOL(zfs_prop_default_string);
+EXPORT_SYMBOL(zfs_prop_default_numeric);
+EXPORT_SYMBOL(zfs_prop_readonly);
+EXPORT_SYMBOL(zfs_prop_inheritable);
+EXPORT_SYMBOL(zfs_prop_setonce);
+EXPORT_SYMBOL(zfs_prop_to_name);
+EXPORT_SYMBOL(zfs_name_to_prop);
+EXPORT_SYMBOL(zfs_prop_user);
+EXPORT_SYMBOL(zfs_prop_index_to_string);
+EXPORT_SYMBOL(zfs_prop_string_to_index);
+EXPORT_SYMBOL(zfs_prop_valid_for_type);
+#endif

zfs/lib/libzcommon/zpool_prop.c

@@ -184,3 +184,19 @@ zpool_prop_align_right(zpool_prop_t prop)
 	return (zpool_prop_table[prop].pd_rightalign);
 }
 #endif
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+/* zpool property functions */
+EXPORT_SYMBOL(zpool_prop_init);
+EXPORT_SYMBOL(zpool_prop_get_type);
+EXPORT_SYMBOL(zpool_prop_get_table);
+
+/* Pool property functions shared between libzfs and kernel. */
+EXPORT_SYMBOL(zpool_name_to_prop);
+EXPORT_SYMBOL(zpool_prop_to_name);
+EXPORT_SYMBOL(zpool_prop_default_string);
+EXPORT_SYMBOL(zpool_prop_default_numeric);
+EXPORT_SYMBOL(zpool_prop_readonly);
+EXPORT_SYMBOL(zpool_prop_index_to_string);
+EXPORT_SYMBOL(zpool_prop_string_to_index);
+#endif

zfs/lib/libzcommon/zprop_common.c

@@ -404,3 +404,20 @@ zprop_width(int prop, boolean_t *fixed, zfs_type_t type)
 }
 
 #endif
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+/* Common routines to initialize property tables */
+EXPORT_SYMBOL(register_impl);
+EXPORT_SYMBOL(register_string);
+EXPORT_SYMBOL(register_number);
+EXPORT_SYMBOL(register_index);
+EXPORT_SYMBOL(register_hidden);
+
+/* Common routines for zfs and zpool property management */
+EXPORT_SYMBOL(zprop_iter_common);
+EXPORT_SYMBOL(zprop_name_to_prop);
+EXPORT_SYMBOL(zprop_string_to_index);
+EXPORT_SYMBOL(zprop_index_to_string);
+EXPORT_SYMBOL(zprop_values);
+EXPORT_SYMBOL(zprop_valid_for_type);
+#endif

zfs/lib/libzfs/libzfs_sendrecv.c

@@ -39,6 +39,7 @@
 #include <sys/mntent.h>
 #include <sys/mnttab.h>
 #include <sys/avl.h>
+#include <sys/debug.h>
 #include <stddef.h>
 
 #include <libzfs.h>

zfs/lib/libzfs/zu.c

@@ -0,0 +1,4 @@
+int main(void)
+{
+       return 0;
+}

zfs/lib/libzpool/arc.c

@@ -168,9 +168,9 @@ static boolean_t arc_warm;
 /*
  * These tunables are for performance analysis.
  */
-uint64_t zfs_arc_max;
+unsigned long zfs_arc_max = 0;
-uint64_t zfs_arc_min;
+unsigned long zfs_arc_min = 0;
-uint64_t zfs_arc_meta_limit = 0;
+unsigned long zfs_arc_meta_limit = 0;
 int zfs_mdcomp_disable = 0;
 
 /*
@@ -4479,3 +4479,21 @@ l2arc_stop(void)
 		cv_wait(&l2arc_feed_thr_cv, &l2arc_feed_thr_lock);
 	mutex_exit(&l2arc_feed_thr_lock);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(arc_read);
+EXPORT_SYMBOL(arc_buf_remove_ref);
+EXPORT_SYMBOL(arc_getbuf_func);
+
+module_param(zfs_arc_min, ulong, 0644);
+MODULE_PARM_DESC(zfs_arc_min, "Minimum arc size");
+
+module_param(zfs_arc_max, ulong, 0644);
+MODULE_PARM_DESC(zfs_arc_max, "Maximum arc size");
+
+module_param(zfs_arc_meta_limit, ulong, 0644);
+MODULE_PARM_DESC(zfs_arc_meta_limit, "Meta limit for arc size");
+
+module_param(zfs_mdcomp_disable, int, 0644);
+MODULE_PARM_DESC(zfs_mdcomp_disable, "Meta compression disable");
+#endif

zfs/lib/libzpool/dbuf.c

@@ -24,6 +24,7 @@
  */
 
 #include <sys/zfs_context.h>
+#include <sys/arc.h>
 #include <sys/dmu.h>
 #include <sys/dmu_impl.h>
 #include <sys/dbuf.h>
@@ -2369,3 +2370,8 @@ dbuf_write_done(zio_t *zio, arc_buf_t *buf, void *vdb)
 
 	dbuf_rele(db, (void *)(uintptr_t)txg);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(dmu_buf_rele);
+EXPORT_SYMBOL(dmu_buf_will_dirty);
+#endif

zfs/lib/libzpool/dmu.c

@@ -1225,3 +1225,23 @@ dmu_fini(void)
 	dbuf_fini();
 	l2arc_fini();
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(dmu_bonus_hold);
+EXPORT_SYMBOL(dmu_free_range);
+EXPORT_SYMBOL(dmu_read);
+EXPORT_SYMBOL(dmu_write);
+
+/* Get information on a DMU object. */
+EXPORT_SYMBOL(dmu_object_info);
+EXPORT_SYMBOL(dmu_object_info_from_dnode);
+EXPORT_SYMBOL(dmu_object_info_from_db);
+EXPORT_SYMBOL(dmu_object_size_from_db);
+
+EXPORT_SYMBOL(dmu_object_set_blocksize);
+EXPORT_SYMBOL(dmu_object_set_checksum);
+EXPORT_SYMBOL(dmu_object_set_compress);
+EXPORT_SYMBOL(dmu_get_replication_level);
+
+EXPORT_SYMBOL(dmu_ot);
+#endif

zfs/lib/libzpool/dmu_object.c

@@ -160,3 +160,11 @@ dmu_object_next(objset_t *os, uint64_t *objectp, boolean_t hole, uint64_t txg)
 
 	return (error);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(dmu_object_alloc);
+EXPORT_SYMBOL(dmu_object_claim);
+EXPORT_SYMBOL(dmu_object_reclaim);
+EXPORT_SYMBOL(dmu_object_free);
+EXPORT_SYMBOL(dmu_object_next);
+#endif

zfs/lib/libzpool/dmu_objset.c

@@ -726,9 +726,11 @@ dmu_objset_snapshot_one(char *name, void *arg)
 	 * doing a recursive snapshot.  The permission checks for the starting
 	 * dataset have already been performed in zfs_secpolicy_snapshot()
 	 */
+#ifdef HAVE_ZPL
 	if (sn->checkperms == B_TRUE &&
 	    (err = zfs_secpolicy_snapshot_perms(name, CRED())))
 		return (err);
+#endif
 
 	err = dmu_objset_open(name, DMU_OST_ANY, DS_MODE_USER, &os);
 	if (err != 0)
@@ -1226,3 +1228,36 @@ dmu_objset_get_user(objset_t *os)
 	ASSERT(MUTEX_HELD(&os->os->os_user_ptr_lock));
 	return (os->os->os_user_ptr);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(dmu_objset_spa);
+EXPORT_SYMBOL(dmu_objset_zil);
+EXPORT_SYMBOL(dmu_objset_pool);
+EXPORT_SYMBOL(dmu_objset_ds);
+EXPORT_SYMBOL(dmu_objset_name);
+EXPORT_SYMBOL(dmu_objset_type);
+EXPORT_SYMBOL(dmu_objset_id);
+EXPORT_SYMBOL(dmu_snapshot_list_next);
+EXPORT_SYMBOL(dmu_dir_list_next);
+EXPORT_SYMBOL(dmu_objset_set_user);
+EXPORT_SYMBOL(dmu_objset_get_user);
+
+/* Public routines to create, destroy, open, and close objsets. */
+EXPORT_SYMBOL(dmu_objset_open);
+EXPORT_SYMBOL(dmu_objset_open_ds);
+EXPORT_SYMBOL(dmu_objset_close);
+EXPORT_SYMBOL(dmu_objset_evict_dbufs);
+EXPORT_SYMBOL(dmu_objset_create);
+EXPORT_SYMBOL(dmu_objset_create_impl);
+EXPORT_SYMBOL(dmu_objset_destroy);
+EXPORT_SYMBOL(dmu_snapshots_destroy);
+EXPORT_SYMBOL(dmu_objset_rollback);
+EXPORT_SYMBOL(dmu_objset_snapshot);
+EXPORT_SYMBOL(dmu_objset_rename);
+EXPORT_SYMBOL(dmu_objset_find);
+EXPORT_SYMBOL(dmu_objset_byteswap);
+
+/* Get stats on a dataset. */
+EXPORT_SYMBOL(dmu_objset_fast_stat);
+EXPORT_SYMBOL(dmu_objset_stats);
+#endif

zfs/lib/libzpool/dmu_traverse.c

@@ -404,3 +404,7 @@ traverse_pool(spa_t *spa, blkptr_cb_t func, void *arg)
 		err = 0;
 	return (err);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(traverse_dsl_dataset);
+#endif

zfs/lib/libzpool/dmu_tx.c

@@ -1127,3 +1127,15 @@ dmu_tx_callback_data_destroy(void *dcb_data)
 
 	return (0);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(dmu_tx_create);
+EXPORT_SYMBOL(dmu_tx_hold_write);
+EXPORT_SYMBOL(dmu_tx_hold_free);
+EXPORT_SYMBOL(dmu_tx_hold_zap);
+EXPORT_SYMBOL(dmu_tx_hold_bonus);
+EXPORT_SYMBOL(dmu_tx_abort);
+EXPORT_SYMBOL(dmu_tx_assign);
+EXPORT_SYMBOL(dmu_tx_wait);
+EXPORT_SYMBOL(dmu_tx_commit);
+#endif

zfs/lib/libzpool/dmu_zfetch.c

@@ -649,3 +649,9 @@ dmu_zfetch(zfetch_t *zf, uint64_t offset, uint64_t size, int prefetched)
 		}
 	}
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+module_param(zfs_prefetch_disable, int, 0644);
+MODULE_PARM_DESC(zfs_prefetch_disable, "Disable all ZFS prefetching");
+#endif
+

zfs/lib/libzpool/dsl_dataset.c

@@ -2093,6 +2093,7 @@ dsl_snapshot_rename_one(char *name, void *arg)
 	 * For recursive snapshot renames the parent won't be changing
 	 * so we just pass name for both the to/from argument.
 	 */
+#ifdef HAVE_ZPL
 	err = zfs_secpolicy_rename_perms(name, name, CRED());
 	if (err == ENOENT) {
 		return (0);
@@ -2100,8 +2101,10 @@ dsl_snapshot_rename_one(char *name, void *arg)
 		(void) strcpy(ra->failed, name);
 		return (err);
 	}
+#endif
 
-#ifdef _KERNEL
+/* XXX: Ignore for SPL version until mounting the FS is supported */
+#if defined(_KERNEL) && !defined(HAVE_SPL)
 	/*
 	 * For all filesystems undergoing rename, we'll need to unmount it.
 	 */
@@ -3101,3 +3104,46 @@ dsl_dataset_set_reservation(const char *dsname, uint64_t reservation)
 	dsl_dataset_rele(ds, FTAG);
 	return (err);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(dsl_dataset_open_spa);
+EXPORT_SYMBOL(dsl_dataset_open);
+EXPORT_SYMBOL(dsl_dataset_open_obj);
+EXPORT_SYMBOL(dsl_dataset_name);
+EXPORT_SYMBOL(dsl_dataset_close);
+EXPORT_SYMBOL(dsl_dataset_downgrade);
+EXPORT_SYMBOL(dsl_dataset_tryupgrade);
+EXPORT_SYMBOL(dsl_dataset_create_sync_impl);
+EXPORT_SYMBOL(dsl_dataset_create_sync);
+EXPORT_SYMBOL(dsl_dataset_destroy);
+EXPORT_SYMBOL(dsl_snapshots_destroy);
+EXPORT_SYMBOL(dsl_dataset_destroy_check);
+EXPORT_SYMBOL(dsl_dataset_destroy_sync);
+EXPORT_SYMBOL(dsl_dataset_snapshot_check);
+EXPORT_SYMBOL(dsl_dataset_snapshot_sync);
+EXPORT_SYMBOL(dsl_dataset_rollback);
+EXPORT_SYMBOL(dsl_dataset_rename);
+EXPORT_SYMBOL(dsl_dataset_promote);
+EXPORT_SYMBOL(dsl_dataset_clone_swap);
+EXPORT_SYMBOL(dsl_dataset_set_user_ptr);
+EXPORT_SYMBOL(dsl_dataset_get_user_ptr);
+EXPORT_SYMBOL(dsl_dataset_set_blkptr);
+EXPORT_SYMBOL(dsl_dataset_get_spa);
+EXPORT_SYMBOL(dsl_dataset_modified_since_lastsnap);
+EXPORT_SYMBOL(dsl_dataset_sync);
+EXPORT_SYMBOL(dsl_dataset_block_born);
+EXPORT_SYMBOL(dsl_dataset_block_kill);
+EXPORT_SYMBOL(dsl_dataset_block_freeable);
+EXPORT_SYMBOL(dsl_dataset_prev_snap_txg);
+EXPORT_SYMBOL(dsl_dataset_dirty);
+EXPORT_SYMBOL(dsl_dataset_stats);
+EXPORT_SYMBOL(dsl_dataset_fast_stat);
+EXPORT_SYMBOL(dsl_dataset_space);
+EXPORT_SYMBOL(dsl_dataset_fsid_guid);
+EXPORT_SYMBOL(dsl_dataset_create_root);
+EXPORT_SYMBOL(dsl_dsobj_to_dsname);
+EXPORT_SYMBOL(dsl_dataset_check_quota);
+EXPORT_SYMBOL(dsl_dataset_set_quota);
+EXPORT_SYMBOL(dsl_dataset_set_quota_sync);
+EXPORT_SYMBOL(dsl_dataset_set_reservation);
+#endif

zfs/lib/libzpool/dsl_deleg.c

@@ -733,3 +733,8 @@ dsl_delegation_on(objset_t *os)
 {
 	return (os->os->os_spa->spa_delegation);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(dsl_deleg_get);
+EXPORT_SYMBOL(dsl_deleg_set);
+#endif

zfs/lib/libzpool/dsl_dir.c

@@ -1328,3 +1328,10 @@ dsl_dir_transfer_possible(dsl_dir_t *sdd, dsl_dir_t *tdd, uint64_t space)
 
 	return (0);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(dsl_dir_set_quota);
+EXPORT_SYMBOL(dsl_dir_set_reservation);
+EXPORT_SYMBOL(dsl_dir_open);
+EXPORT_SYMBOL(dsl_dir_close);
+#endif

zfs/lib/libzpool/dsl_prop.c

@@ -600,3 +600,10 @@ dsl_prop_nvlist_add_string(nvlist_t *nv, zfs_prop_t prop, const char *value)
 	VERIFY(nvlist_add_nvlist(nv, zfs_prop_to_name(prop), propval) == 0);
 	nvlist_free(propval);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(dsl_prop_set);
+EXPORT_SYMBOL(dsl_prop_get_all);
+EXPORT_SYMBOL(dsl_prop_nvlist_add_uint64);
+EXPORT_SYMBOL(dsl_prop_get_integer);
+#endif

zfs/lib/libzpool/dsl_synctask.c

@@ -223,3 +223,8 @@ dsl_sync_task_do_nowait(dsl_pool_t *dp,
 	    arg1, arg2, blocks_modified);
 	dsl_sync_task_group_nowait(dstg, tx);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(dsl_sync_task_do);
+EXPORT_SYMBOL(dsl_sync_task_do_nowait);
+#endif

zfs/lib/libzpool/fletcher.c

@@ -143,3 +143,12 @@ fletcher_4_incremental_byteswap(const void *buf, uint64_t size,
 
 	ZIO_SET_CHECKSUM(zcp, a, b, c, d);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(fletcher_2_native);
+EXPORT_SYMBOL(fletcher_2_byteswap);
+EXPORT_SYMBOL(fletcher_4_native);
+EXPORT_SYMBOL(fletcher_4_byteswap);
+EXPORT_SYMBOL(fletcher_4_incremental_native);
+EXPORT_SYMBOL(fletcher_4_incremental_byteswap);
+#endif

zfs/lib/libzpool/include/sys/zfs_fuid.h

@@ -100,6 +100,7 @@ typedef struct zfs_fuid_info {
 } zfs_fuid_info_t;
 
 #ifdef _KERNEL
+#ifndef HAVE_SPL
 struct znode;
 extern uid_t zfs_fuid_map_id(zfsvfs_t *, uint64_t, cred_t *, zfs_fuid_type_t);
 extern void zfs_fuid_destroy(zfsvfs_t *);
@@ -112,7 +113,7 @@ extern void zfs_fuid_map_ids(struct znode *zp, cred_t *cr, uid_t *uid,
 extern zfs_fuid_info_t *zfs_fuid_info_alloc(void);
 extern void zfs_fuid_info_free();
 extern boolean_t zfs_groupmember(zfsvfs_t *, uint64_t, cred_t *);
-#endif
+#endif /* !HAVE_SPL */
 
 char *zfs_fuid_idx_domain(avl_tree_t *, uint32_t);
 uint64_t zfs_fuid_table_load(objset_t *, uint64_t, avl_tree_t *, avl_tree_t *);
@@ -121,5 +122,6 @@ void zfs_fuid_table_destroy(avl_tree_t *, avl_tree_t *);
 #ifdef	__cplusplus
 }
 #endif
+#endif
 
 #endif	/* _SYS_FS_ZFS_FUID_H */

zfs/lib/libzpool/include/sys/zil.h

@@ -334,7 +334,7 @@ typedef void zil_parse_blk_func_t(zilog_t *zilog, blkptr_t *bp, void *arg,
     uint64_t txg);
 typedef void zil_parse_lr_func_t(zilog_t *zilog, lr_t *lr, void *arg,
     uint64_t txg);
-typedef int zil_replay_func_t();
+typedef int zil_replay_func_t(void *, char *, boolean_t);
 typedef void zil_replay_cleaner_t();
 typedef int zil_get_data_t(void *arg, lr_write_t *lr, char *dbuf, zio_t *zio);
 

zfs/lib/libzpool/spa.c

@@ -41,6 +41,7 @@
 #include <sys/zap.h>
 #include <sys/zil.h>
 #include <sys/vdev_impl.h>
+#include <sys/vdev_disk.h>
 #include <sys/metaslab.h>
 #include <sys/uberblock_impl.h>
 #include <sys/txg.h>
@@ -167,9 +168,11 @@ spa_prop_get(spa_t *spa, nvlist_t **nvp)
 	zap_cursor_t zc;
 	zap_attribute_t za;
 	objset_t *mos = spa->spa_meta_objset;
-	int err;
+	int err = 0;
 
-	VERIFY(nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0);
+	err = nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP);
+	if (err)
+		return err;
 
 	mutex_enter(&spa->spa_props_lock);
 
@@ -181,7 +184,7 @@ spa_prop_get(spa_t *spa, nvlist_t **nvp)
 	/* If no pool property object, no more prop to get. */
 	if (spa->spa_pool_props_object == 0) {
 		mutex_exit(&spa->spa_props_lock);
-		return (0);
+		goto out;
 	}
 
 	/*
@@ -2276,8 +2279,6 @@ spa_build_rootpool_config(nvlist_t *config)
  * Get the root pool information from the root disk, then import the root pool
  * during the system boot up time.
  */
-extern int vdev_disk_read_rootlabel(char *, char *, nvlist_t **);
-
 int
 spa_check_rootconf(char *devpath, char *devid, nvlist_t **bestconf,
     uint64_t *besttxg)
@@ -4301,3 +4302,64 @@ done:
 	sysevent_free(ev);
 #endif
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+/* state manipulation functions */
+EXPORT_SYMBOL(spa_open);
+EXPORT_SYMBOL(spa_get_stats);
+EXPORT_SYMBOL(spa_create);
+EXPORT_SYMBOL(spa_import);
+EXPORT_SYMBOL(spa_tryimport);
+EXPORT_SYMBOL(spa_destroy);
+EXPORT_SYMBOL(spa_export);
+EXPORT_SYMBOL(spa_reset);
+EXPORT_SYMBOL(spa_async_request);
+EXPORT_SYMBOL(spa_async_suspend);
+EXPORT_SYMBOL(spa_async_resume);
+EXPORT_SYMBOL(spa_inject_addref);
+EXPORT_SYMBOL(spa_inject_delref);
+
+/* device maniion */
+EXPORT_SYMBOL(spa_vdev_add);
+EXPORT_SYMBOL(spa_vdev_attach);
+EXPORT_SYMBOL(spa_vdev_detach);
+EXPORT_SYMBOL(spa_vdev_remove);
+EXPORT_SYMBOL(spa_vdev_setpath);
+
+/* spare statech is global across all pools) */
+EXPORT_SYMBOL(spa_spare_add);
+EXPORT_SYMBOL(spa_spare_remove);
+EXPORT_SYMBOL(spa_spare_exists);
+EXPORT_SYMBOL(spa_spare_activate);
+
+/* L2ARC statech is global across all pools) */
+EXPORT_SYMBOL(spa_l2cache_add);
+EXPORT_SYMBOL(spa_l2cache_remove);
+EXPORT_SYMBOL(spa_l2cache_exists);
+EXPORT_SYMBOL(spa_l2cache_activate);
+EXPORT_SYMBOL(spa_l2cache_drop);
+EXPORT_SYMBOL(spa_l2cache_space_update);
+
+/* scrubbing */
+EXPORT_SYMBOL(spa_scrub);
+EXPORT_SYMBOL(spa_scrub_suspend);
+EXPORT_SYMBOL(spa_scrub_resume);
+EXPORT_SYMBOL(spa_scrub_restart);
+
+/* spa syncing */
+EXPORT_SYMBOL(spa_sync); /* only for DMU use */
+EXPORT_SYMBOL(spa_sync_allpools);
+
+/* properties */
+EXPORT_SYMBOL(spa_prop_set);
+EXPORT_SYMBOL(spa_prop_get);
+EXPORT_SYMBOL(spa_prop_clear_bootfs);
+
+#if defined(HAVE_SYSEVENT)
+/* asynchronous event notification */
+EXPORT_SYMBOL(spa_event_notify);
+#endif
+
+module_param(zio_taskq_threads, int, 0644);
+MODULE_PARM_DESC(zio_taskq_threads, "Number of zio_taskq_threads");
+#endif

zfs/lib/libzpool/spa_config.c

@@ -442,3 +442,13 @@ spa_config_update_common(spa_t *spa, int what, boolean_t isroot)
 	if (what == SPA_CONFIG_UPDATE_POOL)
 		spa_config_update_common(spa, SPA_CONFIG_UPDATE_VDEVS, isroot);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(spa_config_sync);
+EXPORT_SYMBOL(spa_config_check);
+EXPORT_SYMBOL(spa_config_load);
+EXPORT_SYMBOL(spa_all_configs);
+EXPORT_SYMBOL(spa_config_set);
+EXPORT_SYMBOL(spa_config_generate);
+EXPORT_SYMBOL(spa_config_update);
+#endif

zfs/lib/libzpool/spa_errlog.c

@@ -435,3 +435,18 @@ spa_errlog_sync(spa_t *spa, uint64_t txg)
 
 	mutex_exit(&spa->spa_errlog_lock);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+/* error handling */
+EXPORT_SYMBOL(spa_log_error);
+EXPORT_SYMBOL(zfs_ereport_post);
+EXPORT_SYMBOL(zfs_post_ok);
+EXPORT_SYMBOL(zfs_post_remove);
+EXPORT_SYMBOL(zfs_post_autoreplace);
+EXPORT_SYMBOL(spa_get_errlog_size);
+EXPORT_SYMBOL(spa_get_errlog);
+EXPORT_SYMBOL(spa_errlog_rotate);
+EXPORT_SYMBOL(spa_errlog_drain);
+EXPORT_SYMBOL(spa_errlog_sync);
+EXPORT_SYMBOL(spa_get_errlists);
+#endif

zfs/lib/libzpool/spa_history.c

@@ -179,7 +179,11 @@ static char *
 spa_history_zone(void)
 {
 #ifdef _KERNEL
+#ifdef HAVE_SPL
+	return ("linux");
+#else
 	return (curproc->p_zone->zone_name);
+#endif
 #else
 	return ("global");
 #endif
@@ -426,3 +430,11 @@ spa_history_internal_log(history_internal_events_t event, spa_t *spa,
 	}
 	/* spa_history_log_sync() will free hap and str */
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+/* history logging */
+EXPORT_SYMBOL(spa_history_create_obj);
+EXPORT_SYMBOL(spa_history_get);
+EXPORT_SYMBOL(spa_history_log);
+EXPORT_SYMBOL(spa_history_internal_log);
+#endif

zfs/lib/libzpool/spa_misc.c

@@ -1408,3 +1408,65 @@ spa_is_root(spa_t *spa)
 {
 	return (spa->spa_is_root);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+/* Namespace manipulation */
+EXPORT_SYMBOL(spa_lookup);
+EXPORT_SYMBOL(spa_add);
+EXPORT_SYMBOL(spa_remove);
+EXPORT_SYMBOL(spa_next);
+
+/* Refcount functions */
+EXPORT_SYMBOL(spa_open_ref);
+EXPORT_SYMBOL(spa_close);
+EXPORT_SYMBOL(spa_refcount_zero);
+
+/* Pool configuration lock */
+EXPORT_SYMBOL(spa_config_enter);
+EXPORT_SYMBOL(spa_config_exit);
+EXPORT_SYMBOL(spa_config_held);
+
+/* Pool vdev add/remove lock */
+EXPORT_SYMBOL(spa_vdev_enter);
+EXPORT_SYMBOL(spa_vdev_exit);
+
+/* Accessor functions */
+EXPORT_SYMBOL(spa_traverse_rwlock);
+EXPORT_SYMBOL(spa_traverse_wanted);
+EXPORT_SYMBOL(spa_get_dsl);
+EXPORT_SYMBOL(spa_get_rootblkptr);
+EXPORT_SYMBOL(spa_set_rootblkptr);
+EXPORT_SYMBOL(spa_altroot);
+EXPORT_SYMBOL(spa_sync_pass);
+EXPORT_SYMBOL(spa_name);
+EXPORT_SYMBOL(spa_guid);
+EXPORT_SYMBOL(spa_last_synced_txg);
+EXPORT_SYMBOL(spa_first_txg);
+EXPORT_SYMBOL(spa_version);
+EXPORT_SYMBOL(spa_state);
+EXPORT_SYMBOL(spa_freeze_txg);
+EXPORT_SYMBOL(spa_get_alloc);
+EXPORT_SYMBOL(spa_get_space);
+EXPORT_SYMBOL(spa_get_dspace);
+EXPORT_SYMBOL(spa_get_asize);
+EXPORT_SYMBOL(spa_max_replication);
+EXPORT_SYMBOL(spa_busy);
+EXPORT_SYMBOL(spa_get_failmode);
+
+/* Miscellaneous support routines */
+EXPORT_SYMBOL(spa_rename);
+EXPORT_SYMBOL(spa_guid_exists);
+EXPORT_SYMBOL(spa_strdup);
+EXPORT_SYMBOL(spa_strfree);
+EXPORT_SYMBOL(spa_get_random);
+EXPORT_SYMBOL(sprintf_blkptr);
+EXPORT_SYMBOL(spa_freeze);
+EXPORT_SYMBOL(spa_upgrade);
+EXPORT_SYMBOL(spa_evict_all);
+EXPORT_SYMBOL(spa_lookup_by_guid);
+EXPORT_SYMBOL(spa_has_spare);
+EXPORT_SYMBOL(bp_get_dasize);
+EXPORT_SYMBOL(spa_has_slogs);
+
+EXPORT_SYMBOL(spa_namespace_lock);
+#endif

zfs/lib/libzpool/txg.c

@@ -719,3 +719,7 @@ txg_list_next(txg_list_t *tl, void *p, uint64_t txg)
 
 	return (tn == NULL ? NULL : (char *)tn - tl->tl_offset);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(txg_wait_synced);
+#endif

zfs/lib/libzpool/vdev.c

@@ -2422,3 +2422,11 @@ vdev_is_bootable(vdev_t *vd)
 	}
 	return (B_TRUE);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(vdev_fault);
+EXPORT_SYMBOL(vdev_degrade);
+EXPORT_SYMBOL(vdev_online);
+EXPORT_SYMBOL(vdev_offline);
+EXPORT_SYMBOL(vdev_clear);
+#endif

zfs/lib/libzpool/vdev_queue.c

@@ -306,3 +306,14 @@ vdev_queue_io_done(zio_t *zio)
 
 	mutex_exit(&vq->vq_lock);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+module_param(zfs_vdev_max_pending, int, 0644);
+MODULE_PARM_DESC(zfs_vdev_max_pending, "Maximum pending VDEV IO");
+
+module_param(zfs_vdev_min_pending, int, 0644);
+MODULE_PARM_DESC(zfs_vdev_min_pending, "Minimum pending VDEV IO");
+
+module_param(zfs_vdev_aggregation_limit, int, 0644);
+MODULE_PARM_DESC(zfs_vdev_aggregation_limit, "Maximum VDEV IO aggregation");
+#endif

zfs/lib/libzpool/zap_micro.c

@@ -1106,3 +1106,9 @@ zap_get_stats(objset_t *os, uint64_t zapobj, zap_stats_t *zs)
 	zap_unlockdir(zap);
 	return (0);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(zap_update);
+EXPORT_SYMBOL(zap_lookup);
+EXPORT_SYMBOL(zap_lookup_norm);
+#endif

zfs/lib/libzpool/zfs_znode.c

@@ -1672,3 +1672,8 @@ zfs_obj_to_path(objset_t *osp, uint64_t obj, char *buf, int len)
 		(void) memmove(buf, path, buf + len - path);
 	return (error);
 }
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+EXPORT_SYMBOL(zfs_create_fs);
+EXPORT_SYMBOL(zfs_obj_to_path);
+#endif

zfs/lib/libzpool/zil.c

@@ -1673,7 +1673,10 @@ zil_replay(objset_t *os, void *arg, uint64_t *txgp,
 	zr.zr_arg = arg;
 	zr.zr_txgp = txgp;
 	zr.zr_byteswap = BP_SHOULD_BYTESWAP(&zh->zh_log);
-	zr.zr_lrbuf = kmem_alloc(2 * SPA_MAXBLOCKSIZE, KM_SLEEP);
+	/* XXX: Changed to use vmem_alloc instead of kmem_alloc for
+	 * large allocation size (I think this is safe here).
+	 */
+	zr.zr_lrbuf = vmem_alloc(2 * SPA_MAXBLOCKSIZE, KM_SLEEP);
 
 	/*
 	 * Wait for in-progress removes to sync before starting replay.
@@ -1685,7 +1688,7 @@ zil_replay(objset_t *os, void *arg, uint64_t *txgp,
 	ASSERT(zilog->zl_replay_blks == 0);
 	(void) zil_parse(zilog, zil_incr_blks, zil_replay_log_record, &zr,
 	    zh->zh_claim_txg);
-	kmem_free(zr.zr_lrbuf, 2 * SPA_MAXBLOCKSIZE);
+	vmem_free(zr.zr_lrbuf, 2 * SPA_MAXBLOCKSIZE);
 
 	zil_destroy(zilog, B_FALSE);
 	txg_wait_synced(zilog->zl_dmu_pool, zilog->zl_destroy_txg);

zfs/lib/libzpool/zio.c

@@ -71,6 +71,7 @@ char *zio_type_name[ZIO_TYPES] = {
 kmem_cache_t *zio_cache;
 kmem_cache_t *zio_buf_cache[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];
 kmem_cache_t *zio_data_buf_cache[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];
+int zio_bulk_flags = 0;
 
 #ifdef _KERNEL
 extern vmem_t *zio_alloc_arena;
@@ -121,12 +122,13 @@ zio_init(void)
 			char name[36];
 			(void) sprintf(name, "zio_buf_%lu", (ulong_t)size);
 			zio_buf_cache[c] = kmem_cache_create(name, size,
-			    align, NULL, NULL, NULL, NULL, NULL, KMC_NODEBUG);
+			    align, NULL, NULL, NULL, NULL, NULL,
+			    KMC_NODEBUG | zio_bulk_flags);
 
 			(void) sprintf(name, "zio_data_buf_%lu", (ulong_t)size);
 			zio_data_buf_cache[c] = kmem_cache_create(name, size,
 			    align, NULL, NULL, NULL, NULL, data_alloc_arena,
-			    KMC_NODEBUG);
+			    KMC_NODEBUG | zio_bulk_flags);
 		}
 	}
 
@@ -2271,3 +2273,21 @@ static zio_pipe_stage_t *zio_pipeline[ZIO_STAGES] = {
 	zio_checksum_verify,
 	zio_done
 };
+
+#if defined(_KERNEL) && defined(HAVE_SPL)
+/* Delegate I/O to a child vdev. */
+EXPORT_SYMBOL(zio_vdev_resume_io);
+
+/* Fault injection */
+EXPORT_SYMBOL(zio_injection_enabled);
+EXPORT_SYMBOL(zio_inject_fault);
+EXPORT_SYMBOL(zio_inject_list_next);
+EXPORT_SYMBOL(zio_clear_fault);
+EXPORT_SYMBOL(zio_priority_table);
+
+module_param(zio_resume_threads, int, 0644);
+MODULE_PARM_DESC(zio_resume_threads, "Number of threads to reissue IO");
+
+module_param(zio_bulk_flags, int, 0644);
+MODULE_PARM_DESC(zio_bulk_flags, "Additional flags to pass to bulk buffers");
+#endif

zfs/lib/libzpool/zu.c

@@ -0,0 +1,4 @@
+int main(void)
+{
+	return 0;
+}