diff --git a/module/os/freebsd/zfs/kmod_core.c b/module/os/freebsd/zfs/kmod_core.c
index a1b1c8e4e6d9..f4c87013dbf0 100644
--- a/module/os/freebsd/zfs/kmod_core.c
+++ b/module/os/freebsd/zfs/kmod_core.c
@@ -1,348 +1,348 @@
 /*
  * Copyright (c) 2020 iXsystems, Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/cmn_err.h>
 #include <sys/conf.h>
 #include <sys/dmu.h>
 #include <sys/dmu_impl.h>
 #include <sys/dmu_objset.h>
 #include <sys/dmu_send.h>
 #include <sys/dmu_tx.h>
 #include <sys/dsl_bookmark.h>
 #include <sys/dsl_crypt.h>
 #include <sys/dsl_dataset.h>
 #include <sys/dsl_deleg.h>
 #include <sys/dsl_destroy.h>
 #include <sys/dsl_dir.h>
 #include <sys/dsl_prop.h>
 #include <sys/dsl_scan.h>
 #include <sys/dsl_userhold.h>
 #include <sys/errno.h>
 #include <sys/eventhandler.h>
 #include <sys/file.h>
 #include <sys/fm/util.h>
 #include <sys/fs/zfs.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/lock.h>
 #include <sys/malloc.h>
 #include <sys/mount.h>
 #include <sys/mutex.h>
 #include <sys/nvpair.h>
 #include <sys/policy.h>
 #include <sys/proc.h>
 #include <sys/sdt.h>
 #include <sys/spa.h>
 #include <sys/spa_impl.h>
 #include <sys/stat.h>
 #include <sys/sunddi.h>
 #include <sys/systm.h>
 #include <sys/taskqueue.h>
 #include <sys/uio.h>
 #include <sys/vdev.h>
 #include <sys/vdev_removal.h>
 #include <sys/zap.h>
 #include <sys/zcp.h>
 #include <sys/zfeature.h>
 #include <sys/zfs_context.h>
 #include <sys/zfs_ctldir.h>
 #include <sys/zfs_dir.h>
 #include <sys/zfs_ioctl.h>
 #include <sys/zfs_ioctl_compat.h>
 #include <sys/zfs_ioctl_impl.h>
 #include <sys/zfs_onexit.h>
 #include <sys/zfs_vfsops.h>
 #include <sys/zfs_znode.h>
 #include <sys/zio_checksum.h>
 #include <sys/zone.h>
 #include <sys/zvol.h>
 
 #include "zfs_comutil.h"
 #include "zfs_deleg.h"
 #include "zfs_namecheck.h"
 #include "zfs_prop.h"
 
 SYSCTL_DECL(_vfs_zfs);
 SYSCTL_DECL(_vfs_zfs_vdev);
 
 extern uint_t rrw_tsd_key;
 static int zfs_version_ioctl = ZFS_IOCVER_OZFS;
 SYSCTL_DECL(_vfs_zfs_version);
 SYSCTL_INT(_vfs_zfs_version, OID_AUTO, ioctl, CTLFLAG_RD, &zfs_version_ioctl,
     0, "ZFS_IOCTL_VERSION");
 
 static struct cdev *zfsdev;
 
 static struct root_hold_token *zfs_root_token;
 
 extern uint_t rrw_tsd_key;
 extern uint_t zfs_allow_log_key;
 extern uint_t zfs_geom_probe_vdev_key;
 
 static int zfs__init(void);
 static int zfs__fini(void);
 static void zfs_shutdown(void *, int);
 
 static eventhandler_tag zfs_shutdown_event_tag;
 
 #define	ZFS_MIN_KSTACK_PAGES 4
 
 static int
 zfsdev_ioctl(struct cdev *dev, ulong_t zcmd, caddr_t arg, int flag,
     struct thread *td)
 {
 	uint_t len;
 	int vecnum;
 	zfs_iocparm_t *zp;
 	zfs_cmd_t *zc;
 #ifdef ZFS_LEGACY_SUPPORT
 	zfs_cmd_legacy_t *zcl;
 #endif
 	int rc, error;
 	void *uaddr;
 
 	len = IOCPARM_LEN(zcmd);
 	vecnum = zcmd & 0xff;
 	zp = (void *)arg;
 	error = 0;
 #ifdef ZFS_LEGACY_SUPPORT
 	zcl = NULL;
 #endif
 
 	if (len != sizeof (zfs_iocparm_t))
 		return (EINVAL);
 
 	uaddr = (void *)zp->zfs_cmd;
-	zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
+	zc = vmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
 #ifdef ZFS_LEGACY_SUPPORT
 	/*
 	 * Remap ioctl code for legacy user binaries
 	 */
 	if (zp->zfs_ioctl_version == ZFS_IOCVER_LEGACY) {
 		vecnum = zfs_ioctl_legacy_to_ozfs(vecnum);
 		if (vecnum < 0) {
-			kmem_free(zc, sizeof (zfs_cmd_t));
+			vmem_free(zc, sizeof (zfs_cmd_t));
 			return (ENOTSUP);
 		}
-		zcl = kmem_zalloc(sizeof (zfs_cmd_legacy_t), KM_SLEEP);
+		zcl = vmem_zalloc(sizeof (zfs_cmd_legacy_t), KM_SLEEP);
 		if (copyin(uaddr, zcl, sizeof (zfs_cmd_legacy_t))) {
 			error = SET_ERROR(EFAULT);
 			goto out;
 		}
 		zfs_cmd_legacy_to_ozfs(zcl, zc);
 	} else
 #endif
 	if (copyin(uaddr, zc, sizeof (zfs_cmd_t))) {
 		error = SET_ERROR(EFAULT);
 		goto out;
 	}
 	error = zfsdev_ioctl_common(vecnum, zc, 0);
 #ifdef ZFS_LEGACY_SUPPORT
 	if (zcl) {
 		zfs_cmd_ozfs_to_legacy(zc, zcl);
 		rc = copyout(zcl, uaddr, sizeof (*zcl));
 	} else
 #endif
 	{
 		rc = copyout(zc, uaddr, sizeof (*zc));
 	}
 	if (error == 0 && rc != 0)
 		error = SET_ERROR(EFAULT);
 out:
 #ifdef ZFS_LEGACY_SUPPORT
 	if (zcl)
-		kmem_free(zcl, sizeof (zfs_cmd_legacy_t));
+		vmem_free(zcl, sizeof (zfs_cmd_legacy_t));
 #endif
-	kmem_free(zc, sizeof (zfs_cmd_t));
+	vmem_free(zc, sizeof (zfs_cmd_t));
 	MPASS(tsd_get(rrw_tsd_key) == NULL);
 	return (error);
 }
 
 static void
 zfsdev_close(void *data)
 {
 	zfsdev_state_destroy(data);
 }
 
 void
 zfsdev_private_set_state(void *priv __unused, zfsdev_state_t *zs)
 {
 	devfs_set_cdevpriv(zs, zfsdev_close);
 }
 
 zfsdev_state_t *
 zfsdev_private_get_state(void *priv)
 {
 	return (priv);
 }
 
 static int
 zfsdev_open(struct cdev *devp __unused, int flag __unused, int mode __unused,
     struct thread *td __unused)
 {
 	int error;
 
 	mutex_enter(&zfsdev_state_lock);
 	error = zfsdev_state_init(NULL);
 	mutex_exit(&zfsdev_state_lock);
 
 	return (error);
 }
 
 static struct cdevsw zfs_cdevsw = {
 	.d_version =	D_VERSION,
 	.d_open =	zfsdev_open,
 	.d_ioctl =	zfsdev_ioctl,
 	.d_name =	ZFS_DRIVER
 };
 
 int
 zfsdev_attach(void)
 {
 	struct make_dev_args args;
 
 	make_dev_args_init(&args);
 	args.mda_flags = MAKEDEV_CHECKNAME | MAKEDEV_WAITOK;
 	args.mda_devsw = &zfs_cdevsw;
 	args.mda_cr = NULL;
 	args.mda_uid = UID_ROOT;
 	args.mda_gid = GID_OPERATOR;
 	args.mda_mode = 0666;
 	return (make_dev_s(&args, &zfsdev, ZFS_DRIVER));
 }
 
 void
 zfsdev_detach(void)
 {
 	if (zfsdev != NULL)
 		destroy_dev(zfsdev);
 }
 
 int
 zfs__init(void)
 {
 	int error;
 
 #if KSTACK_PAGES < ZFS_MIN_KSTACK_PAGES
 	printf("ZFS NOTICE: KSTACK_PAGES is %d which could result in stack "
 	    "overflow panic!\nPlease consider adding "
 	    "'options KSTACK_PAGES=%d' to your kernel config\n", KSTACK_PAGES,
 	    ZFS_MIN_KSTACK_PAGES);
 #endif
 	zfs_root_token = root_mount_hold("ZFS");
 	if ((error = zfs_kmod_init()) != 0) {
 		printf("ZFS: Failed to Load ZFS Filesystem"
 		    ", rc = %d\n", error);
 		root_mount_rel(zfs_root_token);
 		return (error);
 	}
 
 
 	tsd_create(&zfs_geom_probe_vdev_key, NULL);
 
 	printf("ZFS storage pool version: features support ("
 	    SPA_VERSION_STRING ")\n");
 	root_mount_rel(zfs_root_token);
 	ddi_sysevent_init();
 	return (0);
 }
 
 int
 zfs__fini(void)
 {
 	if (zfs_busy() || zvol_busy() ||
 	    zio_injection_enabled) {
 		return (EBUSY);
 	}
 	zfs_kmod_fini();
 	tsd_destroy(&zfs_geom_probe_vdev_key);
 	return (0);
 }
 
 static void
 zfs_shutdown(void *arg __unused, int howto __unused)
 {
 
 	/*
 	 * ZFS fini routines can not properly work in a panic-ed system.
 	 */
 	if (panicstr == NULL)
 		zfs__fini();
 }
 
 static int
 zfs_modevent(module_t mod, int type, void *unused __unused)
 {
 	int err;
 
 	switch (type) {
 	case MOD_LOAD:
 		err = zfs__init();
 		if (err == 0)
 			zfs_shutdown_event_tag = EVENTHANDLER_REGISTER(
 			    shutdown_post_sync, zfs_shutdown, NULL,
 			    SHUTDOWN_PRI_FIRST);
 		return (err);
 	case MOD_UNLOAD:
 		err = zfs__fini();
 		if (err == 0 && zfs_shutdown_event_tag != NULL)
 			EVENTHANDLER_DEREGISTER(shutdown_post_sync,
 			    zfs_shutdown_event_tag);
 		return (err);
 	case MOD_SHUTDOWN:
 		return (0);
 	default:
 		break;
 	}
 	return (EOPNOTSUPP);
 }
 
 static moduledata_t zfs_mod = {
 	"zfsctrl",
 	zfs_modevent,
 	0
 };
 
 #ifdef _KERNEL
 EVENTHANDLER_DEFINE(mountroot, spa_boot_init, NULL, 0);
 #endif
 
 DECLARE_MODULE(zfsctrl, zfs_mod, SI_SUB_CLOCKS, SI_ORDER_ANY);
 MODULE_VERSION(zfsctrl, 1);
 #if __FreeBSD_version > 1300092
 MODULE_DEPEND(zfsctrl, xdr, 1, 1, 1);
 #else
 MODULE_DEPEND(zfsctrl, krpc, 1, 1, 1);
 #endif
 MODULE_DEPEND(zfsctrl, acl_nfs4, 1, 1, 1);
 MODULE_DEPEND(zfsctrl, crypto, 1, 1, 1);
 MODULE_DEPEND(zfsctrl, zlib, 1, 1, 1);
diff --git a/module/os/linux/zfs/zfs_ioctl_os.c b/module/os/linux/zfs/zfs_ioctl_os.c
index f8d1777b07a6..f068f544f0ec 100644
--- a/module/os/linux/zfs/zfs_ioctl_os.c
+++ b/module/os/linux/zfs/zfs_ioctl_os.c
@@ -1,375 +1,375 @@
 /*
  * 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 https://opensource.org/licenses/CDDL-1.0.
  * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Portions Copyright 2011 Martin Matuska
  * Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved.
  * Portions Copyright 2012 Pawel Jakub Dawidek <pawel@dawidek.net>
  * Copyright (c) 2014, 2016 Joyent, Inc. All rights reserved.
  * Copyright 2016 Nexenta Systems, Inc.  All rights reserved.
  * Copyright (c) 2014, Joyent, Inc. All rights reserved.
  * Copyright (c) 2011, 2018 by Delphix. All rights reserved.
  * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
  * Copyright (c) 2013 Steven Hartland. All rights reserved.
  * Copyright (c) 2014 Integros [integros.com]
  * Copyright 2016 Toomas Soome <tsoome@me.com>
  * Copyright (c) 2016 Actifio, Inc. All rights reserved.
  * Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
  * Copyright 2017 RackTop Systems.
  * Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
  * Copyright (c) 2019 Datto Inc.
  * Copyright (c) 2021 Klara, Inc.
  */
 
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/errno.h>
 #include <sys/uio.h>
 #include <sys/file.h>
 #include <sys/kmem.h>
 #include <sys/stat.h>
 #include <sys/zfs_ioctl.h>
 #include <sys/zfs_vfsops.h>
 #include <sys/zap.h>
 #include <sys/spa.h>
 #include <sys/nvpair.h>
 #include <sys/fs/zfs.h>
 #include <sys/zfs_ctldir.h>
 #include <sys/zfs_dir.h>
 #include <sys/zfs_onexit.h>
 #include <sys/zvol.h>
 #include <sys/fm/util.h>
 #include <sys/dsl_crypt.h>
 #include <sys/crypto/icp.h>
 #include <sys/zstd/zstd.h>
 
 #include <sys/zfs_ioctl_impl.h>
 
 #include <sys/zfs_sysfs.h>
 #include <linux/miscdevice.h>
 #include <linux/slab.h>
 
 boolean_t
 zfs_vfs_held(zfsvfs_t *zfsvfs)
 {
 	return (zfsvfs->z_sb != NULL);
 }
 
 int
 zfs_vfs_ref(zfsvfs_t **zfvp)
 {
 	if (*zfvp == NULL || (*zfvp)->z_sb == NULL ||
 	    !atomic_inc_not_zero(&((*zfvp)->z_sb->s_active))) {
 		return (SET_ERROR(ESRCH));
 	}
 	return (0);
 }
 
 void
 zfs_vfs_rele(zfsvfs_t *zfsvfs)
 {
 	deactivate_super(zfsvfs->z_sb);
 }
 
 void
 zfsdev_private_set_state(void *priv, zfsdev_state_t *zs)
 {
 	struct file *filp = priv;
 
 	filp->private_data = zs;
 }
 
 zfsdev_state_t *
 zfsdev_private_get_state(void *priv)
 {
 	struct file *filp = priv;
 
 	return (filp->private_data);
 }
 
 static int
 zfsdev_open(struct inode *ino, struct file *filp)
 {
 	int error;
 
 	mutex_enter(&zfsdev_state_lock);
 	error = zfsdev_state_init(filp);
 	mutex_exit(&zfsdev_state_lock);
 
 	return (-error);
 }
 
 static int
 zfsdev_release(struct inode *ino, struct file *filp)
 {
 	zfsdev_state_destroy(filp);
 
 	return (0);
 }
 
 static long
 zfsdev_ioctl(struct file *filp, unsigned cmd, unsigned long arg)
 {
 	uint_t vecnum;
 	zfs_cmd_t *zc;
 	int error, rc;
 
 	vecnum = cmd - ZFS_IOC_FIRST;
 
-	zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
+	zc = vmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
 
 	if (ddi_copyin((void *)(uintptr_t)arg, zc, sizeof (zfs_cmd_t), 0)) {
 		error = -SET_ERROR(EFAULT);
 		goto out;
 	}
 	error = -zfsdev_ioctl_common(vecnum, zc, 0);
 	rc = ddi_copyout(zc, (void *)(uintptr_t)arg, sizeof (zfs_cmd_t), 0);
 	if (error == 0 && rc != 0)
 		error = -SET_ERROR(EFAULT);
 out:
-	kmem_free(zc, sizeof (zfs_cmd_t));
+	vmem_free(zc, sizeof (zfs_cmd_t));
 	return (error);
 
 }
 
 static int
 zfs_ioc_userns_attach(zfs_cmd_t *zc)
 {
 	int error;
 
 	if (zc == NULL)
 		return (SET_ERROR(EINVAL));
 
 	error = zone_dataset_attach(CRED(), zc->zc_name, zc->zc_cleanup_fd);
 
 	/*
 	 * Translate ENOTTY to ZFS_ERR_NOT_USER_NAMESPACE as we just arrived
 	 * back from the SPL layer, which does not know about ZFS_ERR_* errors.
 	 * See the comment at the user_ns_get() function in spl-zone.c for
 	 * details.
 	 */
 	if (error == ENOTTY)
 		error = ZFS_ERR_NOT_USER_NAMESPACE;
 
 	return (error);
 }
 
 static int
 zfs_ioc_userns_detach(zfs_cmd_t *zc)
 {
 	int error;
 
 	if (zc == NULL)
 		return (SET_ERROR(EINVAL));
 
 	error = zone_dataset_detach(CRED(), zc->zc_name, zc->zc_cleanup_fd);
 
 	/*
 	 * See the comment in zfs_ioc_userns_attach() for details on what is
 	 * going on here.
 	 */
 	if (error == ENOTTY)
 		error = ZFS_ERR_NOT_USER_NAMESPACE;
 
 	return (error);
 }
 
 uint64_t
 zfs_max_nvlist_src_size_os(void)
 {
 	if (zfs_max_nvlist_src_size != 0)
 		return (zfs_max_nvlist_src_size);
 
 	return (MIN(ptob(zfs_totalram_pages) / 4, 128 * 1024 * 1024));
 }
 
 /* Update the VFS's cache of mountpoint properties */
 void
 zfs_ioctl_update_mount_cache(const char *dsname)
 {
 }
 
 void
 zfs_ioctl_init_os(void)
 {
 	zfs_ioctl_register_dataset_nolog(ZFS_IOC_USERNS_ATTACH,
 	    zfs_ioc_userns_attach, zfs_secpolicy_config, POOL_CHECK_NONE);
 	zfs_ioctl_register_dataset_nolog(ZFS_IOC_USERNS_DETACH,
 	    zfs_ioc_userns_detach, zfs_secpolicy_config, POOL_CHECK_NONE);
 }
 
 #ifdef CONFIG_COMPAT
 static long
 zfsdev_compat_ioctl(struct file *filp, unsigned cmd, unsigned long arg)
 {
 	return (zfsdev_ioctl(filp, cmd, arg));
 }
 #else
 #define	zfsdev_compat_ioctl	NULL
 #endif
 
 static const struct file_operations zfsdev_fops = {
 	.open		= zfsdev_open,
 	.release	= zfsdev_release,
 	.unlocked_ioctl	= zfsdev_ioctl,
 	.compat_ioctl	= zfsdev_compat_ioctl,
 	.owner		= THIS_MODULE,
 };
 
 static struct miscdevice zfs_misc = {
 	.minor		= ZFS_DEVICE_MINOR,
 	.name		= ZFS_DRIVER,
 	.fops		= &zfsdev_fops,
 };
 
 MODULE_ALIAS_MISCDEV(ZFS_DEVICE_MINOR);
 MODULE_ALIAS("devname:zfs");
 
 int
 zfsdev_attach(void)
 {
 	int error;
 
 	error = misc_register(&zfs_misc);
 	if (error == -EBUSY) {
 		/*
 		 * Fallback to dynamic minor allocation in the event of a
 		 * collision with a reserved minor in linux/miscdevice.h.
 		 * In this case the kernel modules must be manually loaded.
 		 */
 		printk(KERN_INFO "ZFS: misc_register() with static minor %d "
 		    "failed %d, retrying with MISC_DYNAMIC_MINOR\n",
 		    ZFS_DEVICE_MINOR, error);
 
 		zfs_misc.minor = MISC_DYNAMIC_MINOR;
 		error = misc_register(&zfs_misc);
 	}
 
 	if (error)
 		printk(KERN_INFO "ZFS: misc_register() failed %d\n", error);
 
 	return (error);
 }
 
 void
 zfsdev_detach(void)
 {
 	misc_deregister(&zfs_misc);
 }
 
 #ifdef ZFS_DEBUG
 #define	ZFS_DEBUG_STR	" (DEBUG mode)"
 #else
 #define	ZFS_DEBUG_STR	""
 #endif
 
 static int
 openzfs_init_os(void)
 {
 	int error;
 
 	if ((error = zfs_kmod_init()) != 0) {
 		printk(KERN_NOTICE "ZFS: Failed to Load ZFS Filesystem v%s-%s%s"
 		    ", rc = %d\n", ZFS_META_VERSION, ZFS_META_RELEASE,
 		    ZFS_DEBUG_STR, error);
 
 		return (-error);
 	}
 
 	zfs_sysfs_init();
 
 	printk(KERN_NOTICE "ZFS: Loaded module v%s-%s%s, "
 	    "ZFS pool version %s, ZFS filesystem version %s\n",
 	    ZFS_META_VERSION, ZFS_META_RELEASE, ZFS_DEBUG_STR,
 	    SPA_VERSION_STRING, ZPL_VERSION_STRING);
 #ifndef CONFIG_FS_POSIX_ACL
 	printk(KERN_NOTICE "ZFS: Posix ACLs disabled by kernel\n");
 #endif /* CONFIG_FS_POSIX_ACL */
 
 	return (0);
 }
 
 static void
 openzfs_fini_os(void)
 {
 	zfs_sysfs_fini();
 	zfs_kmod_fini();
 
 	printk(KERN_NOTICE "ZFS: Unloaded module v%s-%s%s\n",
 	    ZFS_META_VERSION, ZFS_META_RELEASE, ZFS_DEBUG_STR);
 }
 
 
 extern int __init zcommon_init(void);
 extern void zcommon_fini(void);
 
 static int __init
 openzfs_init(void)
 {
 	int err;
 	if ((err = zcommon_init()) != 0)
 		goto zcommon_failed;
 	if ((err = icp_init()) != 0)
 		goto icp_failed;
 	if ((err = zstd_init()) != 0)
 		goto zstd_failed;
 	if ((err = openzfs_init_os()) != 0)
 		goto openzfs_os_failed;
 	return (0);
 
 openzfs_os_failed:
 	zstd_fini();
 zstd_failed:
 	icp_fini();
 icp_failed:
 	zcommon_fini();
 zcommon_failed:
 	return (err);
 }
 
 static void __exit
 openzfs_fini(void)
 {
 	openzfs_fini_os();
 	zstd_fini();
 	icp_fini();
 	zcommon_fini();
 }
 
 #if defined(_KERNEL)
 module_init(openzfs_init);
 module_exit(openzfs_fini);
 #endif
 
 MODULE_ALIAS("zavl");
 MODULE_ALIAS("icp");
 MODULE_ALIAS("zlua");
 MODULE_ALIAS("znvpair");
 MODULE_ALIAS("zunicode");
 MODULE_ALIAS("zcommon");
 MODULE_ALIAS("zzstd");
 MODULE_DESCRIPTION("ZFS");
 MODULE_AUTHOR(ZFS_META_AUTHOR);
 MODULE_LICENSE("Dual MIT/GPL"); /* lua */
 MODULE_LICENSE("Dual BSD/GPL"); /* zstd / misc */
 MODULE_LICENSE(ZFS_META_LICENSE);
 MODULE_VERSION(ZFS_META_VERSION "-" ZFS_META_RELEASE);