diff --git a/config/always-arch.m4 b/config/always-arch.m4
index 1ee6099ca8b2..d73b878916cb 100644
--- a/config/always-arch.m4
+++ b/config/always-arch.m4
@@ -1,58 +1,59 @@
 dnl #
 dnl # Set the target cpu architecture.  This allows the
 dnl # following syntax to be used in a Makefile.am.
 dnl #
 dnl # if TARGET_CPU_POWERPC
 dnl # ...
 dnl # else
 dnl # ...
 dnl # endif
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_ARCH], [
 	case $target_cpu in
 	i?86)
 		TARGET_CPU=i386
 		;;
 	amd64|x86_64)
 		TARGET_CPU=x86_64
 		;;
 	powerpc*)
 		TARGET_CPU=powerpc
 		;;
 	aarch64*)
 		TARGET_CPU=aarch64
 		;;
 	armv*)
 		TARGET_CPU=arm
 		;;
 	sparc64)
 		TARGET_CPU=sparc64
 		;;
 	*)
 		TARGET_CPU=$target_cpu
 		;;
 	esac
 
 	AM_CONDITIONAL([TARGET_CPU_AARCH64], test $TARGET_CPU = aarch64)
+	AM_CONDITIONAL([TARGET_CPU_I386],    test $TARGET_CPU = i386)
 	AM_CONDITIONAL([TARGET_CPU_X86_64],  test $TARGET_CPU = x86_64)
 	AM_CONDITIONAL([TARGET_CPU_POWERPC], test $TARGET_CPU = powerpc)
 	AM_CONDITIONAL([TARGET_CPU_SPARC64], test $TARGET_CPU = sparc64)
 	AM_CONDITIONAL([TARGET_CPU_ARM],     test $TARGET_CPU = arm)
 ])
 dnl #
 dnl # Check for conflicting environment variables
 dnl #
 dnl # If ARCH env variable is set up, then kernel Makefile in the /usr/src/kernel
 dnl # can misbehave during the zfs ./configure test of the module compilation.
 AC_DEFUN([ZFS_AC_CONFIG_CHECK_ARCH_VAR], [
 	AC_MSG_CHECKING([for conflicting environment variables])
 	if test -n "$ARCH"; then
 		AC_MSG_RESULT([warning])
 		AC_MSG_WARN(m4_normalize([ARCH environment variable is set to "$ARCH".
     This can cause build kernel modules support check failure.
     Please unset it.]))
 	else
 		AC_MSG_RESULT([done])
 	fi
 ])
 
diff --git a/config/always-compiler-options.m4 b/config/always-compiler-options.m4
index 37fa079e0f4c..0e96435e3713 100644
--- a/config/always-compiler-options.m4
+++ b/config/always-compiler-options.m4
@@ -1,379 +1,400 @@
 dnl #
 dnl # Enabled -fsanitize=address if supported by $CC.
 dnl #
 dnl # LDFLAGS needs -fsanitize=address at all times so libraries compiled with
 dnl # it will be linked successfully. CFLAGS will vary by binary being built.
 dnl #
 dnl # The ASAN_OPTIONS environment variable can be used to further control
 dnl # the behavior of binaries and libraries build with -fsanitize=address.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_ASAN], [
 	AC_MSG_CHECKING([whether to build with -fsanitize=address support])
 	AC_ARG_ENABLE([asan],
 		[AS_HELP_STRING([--enable-asan],
 		[Enable -fsanitize=address support  @<:@default=no@:>@])],
 		[],
 		[enable_asan=no])
 
 	AM_CONDITIONAL([ASAN_ENABLED], [test x$enable_asan = xyes])
 	AC_SUBST([ASAN_ENABLED], [$enable_asan])
 	AC_MSG_RESULT($enable_asan)
 
 	AS_IF([ test "$enable_asan" = "yes" ], [
 		AC_MSG_CHECKING([whether $CC supports -fsanitize=address])
 		saved_cflags="$CFLAGS"
 		CFLAGS="$CFLAGS -Werror -fsanitize=address"
 		AC_LINK_IFELSE([
 			AC_LANG_SOURCE([[ int main() { return 0; } ]])
 		], [
 			ASAN_CFLAGS="-fsanitize=address"
 			ASAN_LDFLAGS="-fsanitize=address"
 			ASAN_ZFS="_with_asan"
 			AC_MSG_RESULT([yes])
 		], [
 			AC_MSG_ERROR([$CC does not support -fsanitize=address])
 		])
 		CFLAGS="$saved_cflags"
 	], [
 		ASAN_CFLAGS=""
 		ASAN_LDFLAGS=""
 		ASAN_ZFS="_without_asan"
 	])
 
 	AC_SUBST([ASAN_CFLAGS])
 	AC_SUBST([ASAN_LDFLAGS])
 	AC_SUBST([ASAN_ZFS])
 ])
 
 dnl #
 dnl # Enabled -fsanitize=undefined if supported by cc.
 dnl #
 dnl # LDFLAGS needs -fsanitize=undefined at all times so libraries compiled with
 dnl # it will be linked successfully. CFLAGS will vary by binary being built.
 dnl #
 dnl # The UBSAN_OPTIONS environment variable can be used to further control
 dnl # the behavior of binaries and libraries build with -fsanitize=undefined.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_UBSAN], [
 	AC_MSG_CHECKING([whether to build with -fsanitize=undefined support])
 	AC_ARG_ENABLE([ubsan],
 		[AS_HELP_STRING([--enable-ubsan],
 		[Enable -fsanitize=undefined support  @<:@default=no@:>@])],
 		[],
 		[enable_ubsan=no])
 
 	AM_CONDITIONAL([UBSAN_ENABLED], [test x$enable_ubsan = xyes])
 	AC_SUBST([UBSAN_ENABLED], [$enable_ubsan])
 	AC_MSG_RESULT($enable_ubsan)
 
 	AS_IF([ test "$enable_ubsan" = "yes" ], [
 		AC_MSG_CHECKING([whether $CC supports -fsanitize=undefined])
 		saved_cflags="$CFLAGS"
 		CFLAGS="$CFLAGS -Werror -fsanitize=undefined"
 		AC_LINK_IFELSE([
 			AC_LANG_SOURCE([[ int main() { return 0; } ]])
 		], [
 			UBSAN_CFLAGS="-fsanitize=undefined"
 			UBSAN_LDFLAGS="-fsanitize=undefined"
 			UBSAN_ZFS="_with_ubsan"
 			AC_MSG_RESULT([yes])
 		], [
 			AC_MSG_ERROR([$CC does not support -fsanitize=undefined])
 		])
 		CFLAGS="$saved_cflags"
 	], [
 		UBSAN_CFLAGS=""
 		UBSAN_LDFLAGS=""
 		UBSAN_ZFS="_without_ubsan"
 	])
 
 	AC_SUBST([UBSAN_CFLAGS])
 	AC_SUBST([UBSAN_LDFLAGS])
 	AC_SUBST([UBSAN_ZFS])
 ])
 
 dnl #
 dnl # Check if cc supports -Wframe-larger-than=<size> option.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_FRAME_LARGER_THAN], [
 	AC_MSG_CHECKING([whether $CC supports -Wframe-larger-than=<size>])
 
 	saved_flags="$CFLAGS"
 	CFLAGS="$CFLAGS -Werror -Wframe-larger-than=4096"
 
 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
 		FRAME_LARGER_THAN="-Wframe-larger-than=4096"
 		AC_MSG_RESULT([yes])
 	], [
 		FRAME_LARGER_THAN=""
 		AC_MSG_RESULT([no])
 	])
 
 	CFLAGS="$saved_flags"
 	AC_SUBST([FRAME_LARGER_THAN])
 ])
 
 dnl #
 dnl # Check if cc supports -Wno-format-truncation option.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_NO_FORMAT_TRUNCATION], [
 	AC_MSG_CHECKING([whether $CC supports -Wno-format-truncation])
 
 	saved_flags="$CFLAGS"
 	CFLAGS="$CFLAGS -Werror -Wno-format-truncation"
 
 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
 		NO_FORMAT_TRUNCATION=-Wno-format-truncation
 		AC_MSG_RESULT([yes])
 	], [
 		NO_FORMAT_TRUNCATION=
 		AC_MSG_RESULT([no])
 	])
 
 	CFLAGS="$saved_flags"
 	AC_SUBST([NO_FORMAT_TRUNCATION])
 ])
 
 dnl #
 dnl # Check if cc supports -Wno-format-zero-length option.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_NO_FORMAT_ZERO_LENGTH], [
 	AC_MSG_CHECKING([whether $CC supports -Wno-format-zero-length])
 
 	saved_flags="$CFLAGS"
 	CFLAGS="$CFLAGS -Werror -Wno-format-zero-length"
 
 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
 		NO_FORMAT_ZERO_LENGTH=-Wno-format-zero-length
 		AC_MSG_RESULT([yes])
 	], [
 		NO_FORMAT_ZERO_LENGTH=
 		AC_MSG_RESULT([no])
 	])
 
 	CFLAGS="$saved_flags"
 	AC_SUBST([NO_FORMAT_ZERO_LENGTH])
 ])
 
 dnl #
 dnl # Check if kernel cc supports -Wno-format-zero-length option.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_KERNEL_CC_NO_FORMAT_ZERO_LENGTH], [
 	saved_cc="$CC"
 	AS_IF(
 		[ test -n "$KERNEL_CC" ], [ CC="$KERNEL_CC" ],
 		[ test -n "$KERNEL_LLVM" ], [ CC="clang" ],
 		[ CC="gcc" ]
 	)
 	AC_MSG_CHECKING([whether $CC supports -Wno-format-zero-length])
 
 	saved_flags="$CFLAGS"
 	CFLAGS="$CFLAGS -Werror -Wno-format-zero-length"
 
 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
 		KERNEL_NO_FORMAT_ZERO_LENGTH=-Wno-format-zero-length
 		AC_MSG_RESULT([yes])
 	], [
 		KERNEL_NO_FORMAT_ZERO_LENGTH=
 		AC_MSG_RESULT([no])
 	])
 
 	CC="$saved_cc"
 	CFLAGS="$saved_flags"
 	AC_SUBST([KERNEL_NO_FORMAT_ZERO_LENGTH])
 ])
 
 dnl #
 dnl # Check if cc supports -Wno-clobbered option.
 dnl #
 dnl # We actually invoke it with the -Wclobbered option
 dnl # and infer the 'no-' version does or doesn't exist based upon
 dnl # the results.  This is required because when checking any of
 dnl # no- prefixed options gcc always returns success.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_NO_CLOBBERED], [
 	AC_MSG_CHECKING([whether $CC supports -Wno-clobbered])
 
 	saved_flags="$CFLAGS"
 	CFLAGS="$CFLAGS -Werror -Wclobbered"
 
 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
 		NO_CLOBBERED=-Wno-clobbered
 		AC_MSG_RESULT([yes])
 	], [
 		NO_CLOBBERED=
 		AC_MSG_RESULT([no])
 	])
 
 	CFLAGS="$saved_flags"
 	AC_SUBST([NO_CLOBBERED])
 ])
 
+dnl #
+dnl # Check if cc supports -Wno-atomic-alignment option.
+dnl #
+AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_NO_ATOMIC_ALIGNMENT], [
+	AC_MSG_CHECKING([whether $CC supports -Wno-atomic-alignment])
+
+	saved_flags="$CFLAGS"
+	CFLAGS="$CFLAGS -Werror -Wno-atomic-alignment"
+
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
+		NO_ATOMIC_ALIGNMENT=-Wno-atomic-alignment
+		AC_MSG_RESULT([yes])
+	], [
+		NO_ATOMIC_ALIGNMENT=
+		AC_MSG_RESULT([no])
+	])
+
+	CFLAGS="$saved_flags"
+	AC_SUBST([NO_ATOMIC_ALIGNMENT])
+])
+
 dnl #
 dnl # Check if cc supports -Wimplicit-fallthrough option.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_IMPLICIT_FALLTHROUGH], [
 	AC_MSG_CHECKING([whether $CC supports -Wimplicit-fallthrough])
 
 	saved_flags="$CFLAGS"
 	CFLAGS="$CFLAGS -Werror -Wimplicit-fallthrough"
 
 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
 		IMPLICIT_FALLTHROUGH=-Wimplicit-fallthrough
 		AC_DEFINE([HAVE_IMPLICIT_FALLTHROUGH], 1,
 			[Define if compiler supports -Wimplicit-fallthrough])
 		AC_MSG_RESULT([yes])
 	], [
 		IMPLICIT_FALLTHROUGH=
 		AC_MSG_RESULT([no])
 	])
 
 	CFLAGS="$saved_flags"
 	AC_SUBST([IMPLICIT_FALLTHROUGH])
 ])
 
 dnl #
 dnl # Check if cc supports -Winfinite-recursion option.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_INFINITE_RECURSION], [
 	AC_MSG_CHECKING([whether $CC supports -Winfinite-recursion])
 
 	saved_flags="$CFLAGS"
 	CFLAGS="$CFLAGS -Werror -Winfinite-recursion"
 
 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
 		INFINITE_RECURSION=-Winfinite-recursion
 		AC_DEFINE([HAVE_INFINITE_RECURSION], 1,
 			[Define if compiler supports -Winfinite-recursion])
 		AC_MSG_RESULT([yes])
 	], [
 		INFINITE_RECURSION=
 		AC_MSG_RESULT([no])
 	])
 
 	CFLAGS="$saved_flags"
 	AC_SUBST([INFINITE_RECURSION])
 ])
 
 dnl #
 dnl # Check if kernel cc supports -Winfinite-recursion option.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_KERNEL_CC_INFINITE_RECURSION], [
 	saved_cc="$CC"
 	AS_IF(
 		[ test -n "$KERNEL_CC" ], [ CC="$KERNEL_CC" ],
 		[ test -n "$KERNEL_LLVM" ], [ CC="clang" ],
 		[ CC="gcc" ]
 	)
 	AC_MSG_CHECKING([whether $CC supports -Winfinite-recursion])
 
 	saved_flags="$CFLAGS"
 	CFLAGS="$CFLAGS -Werror -Winfinite-recursion"
 
 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
 		KERNEL_INFINITE_RECURSION=-Winfinite-recursion
 		AC_DEFINE([HAVE_KERNEL_INFINITE_RECURSION], 1,
 			[Define if compiler supports -Winfinite-recursion])
 		AC_MSG_RESULT([yes])
 	], [
 		KERNEL_INFINITE_RECURSION=
 		AC_MSG_RESULT([no])
 	])
 
 	CC="$saved_cc"
 	CFLAGS="$saved_flags"
 	AC_SUBST([KERNEL_INFINITE_RECURSION])
 ])
 
 dnl #
 dnl # Check if cc supports -Wformat-overflow option.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_FORMAT_OVERFLOW], [
 	AC_MSG_CHECKING([whether $CC supports -Wformat-overflow])
 
 	saved_flags="$CFLAGS"
 	CFLAGS="$CFLAGS -Werror -Wformat-overflow"
 
 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
 		FORMAT_OVERFLOW=-Wformat-overflow
 		AC_DEFINE([HAVE_FORMAT_OVERFLOW], 1,
 			[Define if compiler supports -Wformat-overflow])
 		AC_MSG_RESULT([yes])
 	], [
 		FORMAT_OVERFLOW=
 		AC_MSG_RESULT([no])
 	])
 
 	CFLAGS="$saved_flags"
 	AC_SUBST([FORMAT_OVERFLOW])
 ])
 
 dnl #
 dnl # Check if cc supports -fno-omit-frame-pointer option.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_NO_OMIT_FRAME_POINTER], [
 	AC_MSG_CHECKING([whether $CC supports -fno-omit-frame-pointer])
 
 	saved_flags="$CFLAGS"
 	CFLAGS="$CFLAGS -Werror -fno-omit-frame-pointer"
 
 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
 		NO_OMIT_FRAME_POINTER=-fno-omit-frame-pointer
 		AC_MSG_RESULT([yes])
 	], [
 		NO_OMIT_FRAME_POINTER=
 		AC_MSG_RESULT([no])
 	])
 
 	CFLAGS="$saved_flags"
 	AC_SUBST([NO_OMIT_FRAME_POINTER])
 ])
 
 dnl #
 dnl # Check if cc supports -fno-ipa-sra option.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_CC_NO_IPA_SRA], [
 	AC_MSG_CHECKING([whether $CC supports -fno-ipa-sra])
 
 	saved_flags="$CFLAGS"
 	CFLAGS="$CFLAGS -Werror -fno-ipa-sra"
 
 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
 		NO_IPA_SRA=-fno-ipa-sra
 		AC_MSG_RESULT([yes])
 	], [
 		NO_IPA_SRA=
 		AC_MSG_RESULT([no])
 	])
 
 	CFLAGS="$saved_flags"
 	AC_SUBST([NO_IPA_SRA])
 ])
 
 dnl #
 dnl # Check if kernel cc supports -fno-ipa-sra option.
 dnl #
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS_KERNEL_CC_NO_IPA_SRA], [
 	saved_cc="$CC"
 	AS_IF(
 		[ test -n "$KERNEL_CC" ], [ CC="$KERNEL_CC" ],
 		[ test -n "$KERNEL_LLVM" ], [ CC="clang" ],
 		[ CC="gcc" ]
 	)
 	AC_MSG_CHECKING([whether $CC supports -fno-ipa-sra])
 
 	saved_flags="$CFLAGS"
 	CFLAGS="$CFLAGS -Werror -fno-ipa-sra"
 
 	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])], [
 		KERNEL_NO_IPA_SRA=-fno-ipa-sra
 		AC_MSG_RESULT([yes])
 	], [
 		KERNEL_NO_IPA_SRA=
 		AC_MSG_RESULT([no])
 	])
 
 	CC="$saved_cc"
 	CFLAGS="$saved_flags"
 	AC_SUBST([KERNEL_NO_IPA_SRA])
 ])
diff --git a/config/zfs-build.m4 b/config/zfs-build.m4
index adf6576f3193..161d390466db 100644
--- a/config/zfs-build.m4
+++ b/config/zfs-build.m4
@@ -1,699 +1,700 @@
 AC_DEFUN([ZFS_AC_LICENSE], [
 	AC_MSG_CHECKING([zfs author])
 	AC_MSG_RESULT([$ZFS_META_AUTHOR])
 
 	AC_MSG_CHECKING([zfs license])
 	AC_MSG_RESULT([$ZFS_META_LICENSE])
 ])
 
 AC_DEFUN([ZFS_AC_DEBUG_ENABLE], [
 	DEBUG_CFLAGS="-Werror"
 	DEBUG_CPPFLAGS="-DDEBUG -UNDEBUG"
 	DEBUG_LDFLAGS=""
 	DEBUG_ZFS="_with_debug"
 	WITH_DEBUG="true"
 	AC_DEFINE(ZFS_DEBUG, 1, [zfs debugging enabled])
 
 	KERNEL_DEBUG_CFLAGS="-Werror"
 	KERNEL_DEBUG_CPPFLAGS="-DDEBUG -UNDEBUG"
 ])
 
 AC_DEFUN([ZFS_AC_DEBUG_DISABLE], [
 	DEBUG_CFLAGS=""
 	DEBUG_CPPFLAGS="-UDEBUG -DNDEBUG"
 	DEBUG_LDFLAGS=""
 	DEBUG_ZFS="_without_debug"
 	WITH_DEBUG=""
 
 	KERNEL_DEBUG_CFLAGS=""
 	KERNEL_DEBUG_CPPFLAGS="-UDEBUG -DNDEBUG"
 ])
 
 dnl #
 dnl # When debugging is enabled:
 dnl # - Enable all ASSERTs (-DDEBUG)
 dnl # - Promote all compiler warnings to errors (-Werror)
 dnl #
 dnl # (If INVARIANTS is detected, we need to force DEBUG, or strange panics
 dnl # can ensue.)
 dnl #
 AC_DEFUN([ZFS_AC_DEBUG], [
 	AC_MSG_CHECKING([whether assertion support will be enabled])
 	AC_ARG_ENABLE([debug],
 		[AS_HELP_STRING([--enable-debug],
 		[Enable compiler and code assertions @<:@default=no@:>@])],
 		[],
 		[enable_debug=no])
 
 	AS_CASE(["x$enable_debug"],
 		["xyes"],
 		[ZFS_AC_DEBUG_ENABLE],
 		["xno"],
 		[ZFS_AC_DEBUG_DISABLE],
 		[AC_MSG_ERROR([Unknown option $enable_debug])])
 
 	AS_CASE(["x$enable_invariants"],
 		["xyes"],
 		[],
 		["xno"],
 		[],
 		[ZFS_AC_DEBUG_INVARIANTS_DETECT])
 
 	AS_CASE(["x$enable_invariants"],
 		["xyes"],
 		[ZFS_AC_DEBUG_ENABLE],
 		["xno"],
 		[],
 		[AC_MSG_ERROR([Unknown option $enable_invariants])])
 
 	AC_SUBST(DEBUG_CFLAGS)
 	AC_SUBST(DEBUG_CPPFLAGS)
 	AC_SUBST(DEBUG_LDFLAGS)
 	AC_SUBST(DEBUG_ZFS)
 	AC_SUBST(WITH_DEBUG)
 
 	AC_SUBST(KERNEL_DEBUG_CFLAGS)
 	AC_SUBST(KERNEL_DEBUG_CPPFLAGS)
 
 	AC_MSG_RESULT([$enable_debug])
 ])
 
 AC_DEFUN([ZFS_AC_DEBUGINFO_ENABLE], [
 	DEBUG_CFLAGS="$DEBUG_CFLAGS -g -fno-inline $NO_IPA_SRA"
 
 	KERNEL_DEBUG_CFLAGS="$KERNEL_DEBUG_CFLAGS -fno-inline $KERNEL_NO_IPA_SRA"
 	KERNEL_MAKE="$KERNEL_MAKE CONFIG_DEBUG_INFO=y"
 
 	DEBUGINFO_ZFS="_with_debuginfo"
 ])
 
 AC_DEFUN([ZFS_AC_DEBUGINFO_DISABLE], [
 	DEBUGINFO_ZFS="_without_debuginfo"
 ])
 
 AC_DEFUN([ZFS_AC_DEBUGINFO], [
 	AC_MSG_CHECKING([whether debuginfo support will be forced])
 	AC_ARG_ENABLE([debuginfo],
 		[AS_HELP_STRING([--enable-debuginfo],
 		[Force generation of debuginfo @<:@default=no@:>@])],
 		[],
 		[enable_debuginfo=no])
 
 	AS_CASE(["x$enable_debuginfo"],
 		["xyes"],
 		[ZFS_AC_DEBUGINFO_ENABLE],
 		["xno"],
 		[ZFS_AC_DEBUGINFO_DISABLE],
 		[AC_MSG_ERROR([Unknown option $enable_debuginfo])])
 
 	AC_SUBST(DEBUG_CFLAGS)
 	AC_SUBST(DEBUGINFO_ZFS)
 
 	AC_SUBST(KERNEL_DEBUG_CFLAGS)
 	AC_SUBST(KERNEL_MAKE)
 
 	AC_MSG_RESULT([$enable_debuginfo])
 ])
 
 dnl #
 dnl # Disabled by default, provides basic memory tracking.  Track the total
 dnl # number of bytes allocated with kmem_alloc() and freed with kmem_free().
 dnl # Then at module unload time if any bytes were leaked it will be reported
 dnl # on the console.
 dnl #
 AC_DEFUN([ZFS_AC_DEBUG_KMEM], [
 	AC_MSG_CHECKING([whether basic kmem accounting is enabled])
 	AC_ARG_ENABLE([debug-kmem],
 		[AS_HELP_STRING([--enable-debug-kmem],
 		[Enable basic kmem accounting @<:@default=no@:>@])],
 		[],
 		[enable_debug_kmem=no])
 
 	AS_IF([test "x$enable_debug_kmem" = xyes], [
 		KERNEL_DEBUG_CPPFLAGS="${KERNEL_DEBUG_CPPFLAGS} -DDEBUG_KMEM"
 		DEBUG_KMEM_ZFS="_with_debug_kmem"
 	], [
 		DEBUG_KMEM_ZFS="_without_debug_kmem"
 	])
 
 	AC_SUBST(KERNEL_DEBUG_CPPFLAGS)
 	AC_SUBST(DEBUG_KMEM_ZFS)
 
 	AC_MSG_RESULT([$enable_debug_kmem])
 ])
 
 dnl #
 dnl # Disabled by default, provides detailed memory tracking.  This feature
 dnl # also requires --enable-debug-kmem to be set.  When enabled not only will
 dnl # total bytes be tracked but also the location of every kmem_alloc() and
 dnl # kmem_free().  When the module is unloaded a list of all leaked addresses
 dnl # and where they were allocated will be dumped to the console.  Enabling
 dnl # this feature has a significant impact on performance but it makes finding
 dnl # memory leaks straight forward.
 dnl #
 AC_DEFUN([ZFS_AC_DEBUG_KMEM_TRACKING], [
 	AC_MSG_CHECKING([whether detailed kmem tracking is enabled])
 	AC_ARG_ENABLE([debug-kmem-tracking],
 		[AS_HELP_STRING([--enable-debug-kmem-tracking],
 		[Enable detailed kmem tracking  @<:@default=no@:>@])],
 		[],
 		[enable_debug_kmem_tracking=no])
 
 	AS_IF([test "x$enable_debug_kmem_tracking" = xyes], [
 		KERNEL_DEBUG_CPPFLAGS="${KERNEL_DEBUG_CPPFLAGS} -DDEBUG_KMEM_TRACKING"
 		DEBUG_KMEM_TRACKING_ZFS="_with_debug_kmem_tracking"
 	], [
 		DEBUG_KMEM_TRACKING_ZFS="_without_debug_kmem_tracking"
 	])
 
 	AC_SUBST(KERNEL_DEBUG_CPPFLAGS)
 	AC_SUBST(DEBUG_KMEM_TRACKING_ZFS)
 
 	AC_MSG_RESULT([$enable_debug_kmem_tracking])
 ])
 
 AC_DEFUN([ZFS_AC_DEBUG_INVARIANTS_DETECT_FREEBSD], [
 	AS_IF([sysctl -n kern.conftxt | grep -Fqx $'options\tINVARIANTS'],
 		[enable_invariants="yes"],
 		[enable_invariants="no"])
 ])
 
 AC_DEFUN([ZFS_AC_DEBUG_INVARIANTS_DETECT], [
 	AM_COND_IF([BUILD_FREEBSD],
 		[ZFS_AC_DEBUG_INVARIANTS_DETECT_FREEBSD],
 		[enable_invariants="no"])
 ])
 
 dnl #
 dnl # Detected for the running kernel by default, enables INVARIANTS features
 dnl # in the FreeBSD kernel module.  This feature must be used when building
 dnl # for a FreeBSD kernel with "options INVARIANTS" in the KERNCONF and must
 dnl # not be used when the INVARIANTS option is absent.
 dnl #
 AC_DEFUN([ZFS_AC_DEBUG_INVARIANTS], [
 	AC_MSG_CHECKING([whether FreeBSD kernel INVARIANTS checks are enabled])
 	AC_ARG_ENABLE([invariants],
 		[AS_HELP_STRING([--enable-invariants],
 		[Enable FreeBSD kernel INVARIANTS checks [[default: detect]]])],
 		[], [ZFS_AC_DEBUG_INVARIANTS_DETECT])
 
 	AS_IF([test "x$enable_invariants" = xyes],
 		[WITH_INVARIANTS="true"],
 		[WITH_INVARIANTS=""])
 	AC_SUBST(WITH_INVARIANTS)
 
 	AC_MSG_RESULT([$enable_invariants])
 ])
 
 dnl # Disabled by default. If enabled allows a configured "turn objtools
 dnl # warnings into errors" (CONFIG_OBJTOOL_WERROR) behavior to take effect.
 dnl # If disabled, objtool warnings are never turned into errors. It can't
 dnl # be enabled if the kernel wasn't compiled with CONFIG_OBJTOOL_WERROR=y.
 dnl #
 AC_DEFUN([ZFS_AC_OBJTOOL_WERROR], [
 	AC_MSG_CHECKING([whether objtool error on warning behavior is enabled])
 	AC_ARG_ENABLE([objtool-werror],
 		[AS_HELP_STRING([--enable-objtool-werror],
 		[Enable objtool's error on warning behaviour if present @<:@default=no@:>@])],
 		[enable_objtool_werror=$enableval],
 		[enable_objtool_werror=no])
 	AC_MSG_RESULT([$enable_objtool_werror])
 
 	AS_IF([test x$CONFIG_OBJTOOL_WERROR_DEFINED = xyes],[
 		AS_IF([test x$enable_objtool_werror = xyes],[
 			AC_MSG_NOTICE([enable-objtool-werror defined, keeping -Werror ])
 		],[
 			AC_MSG_NOTICE([enable-objtool-werror undefined, disabling -Werror ])
 			OBJTOOL_DISABLE_WERROR=y
 			abs_objtool_binary=$kernelsrc/tools/objtool/objtool
 			AS_IF([test -x $abs_objtool_binary],[],[
 				AC_MSG_ERROR([*** objtool binary $abs_objtool_binary not found])
 			])
 			dnl # The path to the wrapper is defined in modules/Makefile.in.
 		])
 	],[
 		dnl # We can't enable --Werror if it's not there.
 		AS_IF([test x$enable_objtool_werror = xyes],[
 			AC_MSG_ERROR([
 	*** Cannot enable objtool-werror,
 	*** a kernel built with CONFIG_OBJTOOL_WERROR=y is required.
 			])
 		],[])
 	])
 
 	AC_SUBST(OBJTOOL_DISABLE_WERROR)
 	AC_SUBST(abs_objtool_binary)
 ])
 
 AC_DEFUN([ZFS_AC_CONFIG_ALWAYS], [
 	AX_COUNT_CPUS([])
 	AC_SUBST(CPU_COUNT)
 
 	ZFS_AC_CONFIG_ALWAYS_CC_NO_CLOBBERED
 	ZFS_AC_CONFIG_ALWAYS_CC_INFINITE_RECURSION
 	ZFS_AC_CONFIG_ALWAYS_KERNEL_CC_INFINITE_RECURSION
+	ZFS_AC_CONFIG_ALWAYS_CC_NO_ATOMIC_ALIGNMENT
 	ZFS_AC_CONFIG_ALWAYS_CC_IMPLICIT_FALLTHROUGH
 	ZFS_AC_CONFIG_ALWAYS_CC_FRAME_LARGER_THAN
 	ZFS_AC_CONFIG_ALWAYS_CC_NO_FORMAT_TRUNCATION
 	ZFS_AC_CONFIG_ALWAYS_CC_NO_FORMAT_ZERO_LENGTH
 	ZFS_AC_CONFIG_ALWAYS_KERNEL_CC_NO_FORMAT_ZERO_LENGTH
 	ZFS_AC_CONFIG_ALWAYS_CC_FORMAT_OVERFLOW
 	ZFS_AC_CONFIG_ALWAYS_CC_NO_OMIT_FRAME_POINTER
 	ZFS_AC_CONFIG_ALWAYS_CC_NO_IPA_SRA
 	ZFS_AC_CONFIG_ALWAYS_KERNEL_CC_NO_IPA_SRA
 	ZFS_AC_CONFIG_ALWAYS_CC_ASAN
 	ZFS_AC_CONFIG_ALWAYS_CC_UBSAN
 	ZFS_AC_CONFIG_ALWAYS_TOOLCHAIN_SIMD
 	ZFS_AC_CONFIG_ALWAYS_SYSTEM
 	ZFS_AC_CONFIG_ALWAYS_ARCH
 	ZFS_AC_CONFIG_CHECK_ARCH_VAR
 	ZFS_AC_CONFIG_ALWAYS_PYTHON
 	ZFS_AC_CONFIG_ALWAYS_PYZFS
 	ZFS_AC_CONFIG_ALWAYS_SED
 	ZFS_AC_CONFIG_ALWAYS_CPPCHECK
 	ZFS_AC_CONFIG_ALWAYS_SHELLCHECK
 	ZFS_AC_CONFIG_ALWAYS_PARALLEL
 ])
 
 AC_DEFUN([ZFS_AC_CONFIG], [
 
         dnl # Remove the previous build test directory.
         rm -Rf build
 
 	ZFS_CONFIG=all
 	AC_ARG_WITH([config],
 		AS_HELP_STRING([--with-config=CONFIG],
 		[Config file 'kernel|user|all|srpm']),
 		[ZFS_CONFIG="$withval"])
 	AC_ARG_ENABLE([linux-builtin],
 		[AS_HELP_STRING([--enable-linux-builtin],
 		[Configure for builtin in-tree kernel modules @<:@default=no@:>@])],
 		[],
 		[enable_linux_builtin=no])
 
 	AC_MSG_CHECKING([zfs config])
 	AC_MSG_RESULT([$ZFS_CONFIG]);
 	AC_SUBST(ZFS_CONFIG)
 
 	ZFS_AC_CONFIG_ALWAYS
 
 	AM_COND_IF([BUILD_LINUX], [
 		AC_ARG_VAR([TEST_JOBS], [simultaneous jobs during configure])
 		if test "x$ac_cv_env_TEST_JOBS_set" != "xset"; then
 			TEST_JOBS=$CPU_COUNT
 		fi
 		AC_SUBST(TEST_JOBS)
 	])
 
 	ZFS_INIT_SYSV=
 	ZFS_INIT_SYSTEMD=
 	ZFS_WANT_MODULES_LOAD_D=
 
 	case "$ZFS_CONFIG" in
 		kernel) ZFS_AC_CONFIG_KERNEL ;;
 		user)	ZFS_AC_CONFIG_USER   ;;
 		all)    ZFS_AC_CONFIG_USER
 			ZFS_AC_CONFIG_KERNEL ;;
 		dist)                        ;;
 		srpm)                        ;;
 		*)
 		AC_MSG_RESULT([Error!])
 		AC_MSG_ERROR([Bad value "$ZFS_CONFIG" for --with-config,
 		              user kernel|user|all|srpm]) ;;
 	esac
 
 	AM_CONDITIONAL([INIT_SYSV],           [test "x$ZFS_INIT_SYSV" = "xyes"])
 	AM_CONDITIONAL([INIT_SYSTEMD],        [test "x$ZFS_INIT_SYSTEMD" = "xyes"])
 	AM_CONDITIONAL([WANT_MODULES_LOAD_D], [test "x$ZFS_WANT_MODULES_LOAD_D" = "xyes"])
 
 	AM_CONDITIONAL([CONFIG_USER],
 	    [test "$ZFS_CONFIG" = user -o "$ZFS_CONFIG" = all])
 	AM_CONDITIONAL([CONFIG_KERNEL],
 	    [test "$ZFS_CONFIG" = kernel -o "$ZFS_CONFIG" = all] &&
 	    [test "x$enable_linux_builtin" != xyes ])
 	AM_CONDITIONAL([CONFIG_QAT],
 	    [test "$ZFS_CONFIG" = kernel -o "$ZFS_CONFIG" = all] &&
 	    [test "x$qatsrc" != x ])
 	AM_CONDITIONAL([WANT_DEVNAME2DEVID], [test "x$user_libudev" = xyes ])
 	AM_CONDITIONAL([WANT_MMAP_LIBAIO], [test "x$user_libaio" = xyes ])
 	AM_CONDITIONAL([PAM_ZFS_ENABLED], [test "x$enable_pam" = xyes])
 ])
 
 dnl #
 dnl # Check for rpm+rpmbuild to build RPM packages.  If these tools
 dnl # are missing it is non-fatal but you will not be able to build
 dnl # RPM packages and will be warned if you try too.
 dnl #
 dnl # By default the generic spec file will be used because it requires
 dnl # minimal dependencies.  Distribution specific spec files can be
 dnl # placed under the 'rpm/<distribution>' directory and enabled using
 dnl # the --with-spec=<distribution> configure option.
 dnl #
 AC_DEFUN([ZFS_AC_RPM], [
 	RPM=rpm
 	RPMBUILD=rpmbuild
 
 	AC_MSG_CHECKING([whether $RPM is available])
 	AS_IF([tmp=$($RPM --version 2>/dev/null)], [
 		RPM_VERSION=$(echo $tmp | $AWK '/RPM/ { print $[3] }')
 		HAVE_RPM=yes
 		AC_MSG_RESULT([$HAVE_RPM ($RPM_VERSION)])
 	],[
 		HAVE_RPM=no
 		AC_MSG_RESULT([$HAVE_RPM])
 	])
 
 	AC_MSG_CHECKING([whether $RPMBUILD is available])
 	AS_IF([tmp=$($RPMBUILD --version 2>/dev/null)], [
 		RPMBUILD_VERSION=$(echo $tmp | $AWK '/RPM/ { print $[3] }')
 		HAVE_RPMBUILD=yes
 		AC_MSG_RESULT([$HAVE_RPMBUILD ($RPMBUILD_VERSION)])
 	],[
 		HAVE_RPMBUILD=no
 		AC_MSG_RESULT([$HAVE_RPMBUILD])
 	])
 
 	RPM_DEFINE_COMMON='--define "$(DEBUG_ZFS) 1"'
 	RPM_DEFINE_COMMON=${RPM_DEFINE_COMMON}' --define "$(DEBUGINFO_ZFS) 1"'
 	RPM_DEFINE_COMMON=${RPM_DEFINE_COMMON}' --define "$(DEBUG_KMEM_ZFS) 1"'
 	RPM_DEFINE_COMMON=${RPM_DEFINE_COMMON}' --define "$(DEBUG_KMEM_TRACKING_ZFS) 1"'
 	RPM_DEFINE_COMMON=${RPM_DEFINE_COMMON}' --define "$(ASAN_ZFS) 1"'
 	RPM_DEFINE_COMMON=${RPM_DEFINE_COMMON}' --define "$(UBSAN_ZFS) 1"'
 
 	AS_IF([test "x$enable_debuginfo" = xyes], [
 		RPM_DEFINE_COMMON=${RPM_DEFINE_COMMON}' --define "__strip /bin/true"'
 	])
 
 	RPM_DEFINE_UTIL=' --define "_initconfdir $(initconfdir)"'
 
 	dnl # Make the next three RPM_DEFINE_UTIL additions conditional, since
 	dnl # their values may not be set when running:
 	dnl #
 	dnl #	./configure --with-config=srpm
 	dnl #
 	AS_IF([test -n "$dracutdir" ], [
 		RPM_DEFINE_UTIL=${RPM_DEFINE_UTIL}' --define "_dracutdir $(dracutdir)"'
 	])
 	AS_IF([test -n "$udevdir" ], [
 		RPM_DEFINE_UTIL=${RPM_DEFINE_UTIL}' --define "_udevdir $(udevdir)"'
 	])
 	AS_IF([test -n "$udevruledir" ], [
 		RPM_DEFINE_UTIL=${RPM_DEFINE_UTIL}' --define "_udevruledir $(udevruledir)"'
 	])
 	AS_IF([test -n "$bashcompletiondir" ], [
 		RPM_DEFINE_UTIL=${RPM_DEFINE_UTIL}' --define "_bashcompletiondir $(bashcompletiondir)"'
 	])
 	RPM_DEFINE_UTIL=${RPM_DEFINE_UTIL}' $(DEFINE_SYSTEMD)'
 	RPM_DEFINE_UTIL=${RPM_DEFINE_UTIL}' $(DEFINE_PYZFS)'
 	RPM_DEFINE_UTIL=${RPM_DEFINE_UTIL}' $(DEFINE_PAM)'
 	RPM_DEFINE_UTIL=${RPM_DEFINE_UTIL}' $(DEFINE_PYTHON_VERSION)'
 	RPM_DEFINE_UTIL=${RPM_DEFINE_UTIL}' $(DEFINE_PYTHON_PKG_VERSION)'
 
 	dnl # Override default lib directory on Debian/Ubuntu systems.  The
 	dnl # provided /usr/lib/rpm/platform/<arch>/macros files do not
 	dnl # specify the correct path for multiarch systems as described
 	dnl # by the packaging guidelines.
 	dnl #
 	dnl # https://wiki.ubuntu.com/MultiarchSpec
 	dnl # https://wiki.debian.org/Multiarch/Implementation
 	dnl #
 	AS_IF([test "$DEFAULT_PACKAGE" = "deb"], [
 		MULTIARCH_LIBDIR="lib/$(dpkg-architecture -qDEB_HOST_MULTIARCH)"
 		RPM_DEFINE_UTIL=${RPM_DEFINE_UTIL}' --define "_lib $(MULTIARCH_LIBDIR)"'
 		AC_SUBST(MULTIARCH_LIBDIR)
 	])
 
 	dnl # Make RPM_DEFINE_KMOD additions conditional on CONFIG_KERNEL,
 	dnl # since the values will not be set otherwise. The spec files
 	dnl # provide defaults for them.
 	dnl #
 	RPM_DEFINE_KMOD='--define "_wrong_version_format_terminate_build 0"'
 	AM_COND_IF([CONFIG_KERNEL], [
 		RPM_DEFINE_KMOD=${RPM_DEFINE_KMOD}' --define "kernels $(LINUX_VERSION)"'
 		RPM_DEFINE_KMOD=${RPM_DEFINE_KMOD}' --define "ksrc $(LINUX)"'
 		RPM_DEFINE_KMOD=${RPM_DEFINE_KMOD}' --define "kobj $(LINUX_OBJ)"'
 		RPM_DEFINE_KMOD=${RPM_DEFINE_KMOD}' --define "kernel_cc KERNEL_CC=$(KERNEL_CC)"'
 		RPM_DEFINE_KMOD=${RPM_DEFINE_KMOD}' --define "kernel_ld KERNEL_LD=$(KERNEL_LD)"'
 		RPM_DEFINE_KMOD=${RPM_DEFINE_KMOD}' --define "kernel_llvm KERNEL_LLVM=$(KERNEL_LLVM)"'
 		RPM_DEFINE_KMOD=${RPM_DEFINE_KMOD}' --define "kernel_cross_compile KERNEL_CROSS_COMPILE=$(KERNEL_CROSS_COMPILE)"'
 		RPM_DEFINE_KMOD=${RPM_DEFINE_KMOD}' --define "kernel_arch KERNEL_ARCH=$(KERNEL_ARCH)"'
 	])
 
 	RPM_DEFINE_DKMS=''
 
 	SRPM_DEFINE_COMMON='--define "build_src_rpm 1"'
 	SRPM_DEFINE_UTIL=
 	SRPM_DEFINE_KMOD=
 	SRPM_DEFINE_DKMS=
 
 	RPM_SPEC_DIR="rpm/generic"
 	AC_ARG_WITH([spec],
 		AS_HELP_STRING([--with-spec=SPEC],
 		[Spec files 'generic|redhat']),
 		[RPM_SPEC_DIR="rpm/$withval"])
 
 	AC_MSG_CHECKING([whether spec files are available])
 	AC_MSG_RESULT([yes ($RPM_SPEC_DIR/*.spec.in)])
 
 	AC_SUBST(HAVE_RPM)
 	AC_SUBST(RPM)
 	AC_SUBST(RPM_VERSION)
 
 	AC_SUBST(HAVE_RPMBUILD)
 	AC_SUBST(RPMBUILD)
 	AC_SUBST(RPMBUILD_VERSION)
 
 	AC_SUBST(RPM_SPEC_DIR)
 	AC_SUBST(RPM_DEFINE_UTIL)
 	AC_SUBST(RPM_DEFINE_KMOD)
 	AC_SUBST(RPM_DEFINE_DKMS)
 	AC_SUBST(RPM_DEFINE_COMMON)
 	AC_SUBST(SRPM_DEFINE_UTIL)
 	AC_SUBST(SRPM_DEFINE_KMOD)
 	AC_SUBST(SRPM_DEFINE_DKMS)
 	AC_SUBST(SRPM_DEFINE_COMMON)
 ])
 
 dnl #
 dnl # Check for dpkg+dpkg-buildpackage to build DEB packages.  If these
 dnl # tools are missing it is non-fatal but you will not be able to build
 dnl # DEB packages and will be warned if you try too.
 dnl #
 AC_DEFUN([ZFS_AC_DPKG], [
 	DPKG=dpkg
 	DPKGBUILD=dpkg-buildpackage
 
 	AC_MSG_CHECKING([whether $DPKG is available])
 	AS_IF([tmp=$($DPKG --version 2>/dev/null)], [
 		DPKG_VERSION=$(echo $tmp | $AWK '/Debian/ { print $[7] }')
 		HAVE_DPKG=yes
 		AC_MSG_RESULT([$HAVE_DPKG ($DPKG_VERSION)])
 	],[
 		HAVE_DPKG=no
 		AC_MSG_RESULT([$HAVE_DPKG])
 	])
 
 	AC_MSG_CHECKING([whether $DPKGBUILD is available])
 	AS_IF([tmp=$($DPKGBUILD --version 2>/dev/null)], [
 		DPKGBUILD_VERSION=$(echo $tmp | \
 		    $AWK '/Debian/ { print $[4] }' | cut -f-4 -d'.')
 		HAVE_DPKGBUILD=yes
 		AC_MSG_RESULT([$HAVE_DPKGBUILD ($DPKGBUILD_VERSION)])
 	],[
 		HAVE_DPKGBUILD=no
 		AC_MSG_RESULT([$HAVE_DPKGBUILD])
 	])
 
 	AC_SUBST(HAVE_DPKG)
 	AC_SUBST(DPKG)
 	AC_SUBST(DPKG_VERSION)
 
 	AC_SUBST(HAVE_DPKGBUILD)
 	AC_SUBST(DPKGBUILD)
 	AC_SUBST(DPKGBUILD_VERSION)
 	AC_SUBST([CFGOPTS], ["$CFGOPTS"])
 ])
 
 dnl #
 dnl # Until native packaging for various different packing systems
 dnl # can be added the least we can do is attempt to use alien to
 dnl # convert the RPM packages to the needed package type.  This is
 dnl # a hack but so far it has worked reasonable well.
 dnl #
 AC_DEFUN([ZFS_AC_ALIEN], [
 	ALIEN=alien
 
 	AC_MSG_CHECKING([whether $ALIEN is available])
 	AS_IF([tmp=$($ALIEN --version 2>/dev/null)], [
 		ALIEN_VERSION=$(echo $tmp | $AWK '{ print $[3] }')
 		ALIEN_MAJOR=$(echo ${ALIEN_VERSION} | $AWK -F'.' '{ print $[1] }')
 		ALIEN_MINOR=$(echo ${ALIEN_VERSION} | $AWK -F'.' '{ print $[2] }')
 		ALIEN_POINT=$(echo ${ALIEN_VERSION} | $AWK -F'.' '{ print $[3] }')
 		HAVE_ALIEN=yes
 		AC_MSG_RESULT([$HAVE_ALIEN ($ALIEN_VERSION)])
 	],[
 		HAVE_ALIEN=no
 		AC_MSG_RESULT([$HAVE_ALIEN])
 	])
 
 	AC_SUBST(HAVE_ALIEN)
 	AC_SUBST(ALIEN)
 	AC_SUBST(ALIEN_VERSION)
 	AC_SUBST(ALIEN_MAJOR)
 	AC_SUBST(ALIEN_MINOR)
 	AC_SUBST(ALIEN_POINT)
 ])
 
 dnl #
 dnl # Using the VENDOR tag from config.guess set the default
 dnl # package type for 'make pkg': (rpm | deb | tgz)
 dnl #
 AC_DEFUN([ZFS_AC_DEFAULT_PACKAGE], [
 	AC_MSG_CHECKING([os distribution])
 	AC_ARG_WITH([vendor],
 		[AS_HELP_STRING([--with-vendor],
 			[Distribution vendor @<:@default=check@:>@])],
 		[with_vendor=$withval],
 		[with_vendor=check])
 	AS_IF([test "x$with_vendor" = "xcheck"],[
 		if test -f /etc/alpine-release ; then
 			VENDOR=alpine ;
 		elif test -f /etc/arch-release ; then
 			VENDOR=arch ;
 		elif test -f /etc/artix-release ; then
 			VENDOR=artix ;
 		elif test -f /etc/fedora-release ; then
 			VENDOR=fedora ;
 		elif test -f /bin/freebsd-version ; then
 			VENDOR=freebsd ;
 		elif test -f /etc/gentoo-release ; then
 			VENDOR=gentoo ;
 		elif test -f /etc/lunar.release ; then
 			VENDOR=lunar ;
 		elif test -f /etc/openEuler-release ; then
 			VENDOR=openeuler ;
 		elif test -f /etc/SuSE-release ; then
 			VENDOR=sles ;
 		elif test -f /etc/slackware-version ; then
 			VENDOR=slackware ;
 		elif test -f /etc/toss-release ; then
 			VENDOR=toss ;
 		elif test -f /etc/lsb-release ; then
 			VENDOR=ubuntu ;
 		# put debian and redhat last as derivatives may have also their file
 		elif test -f /etc/debian_version ; then
 			VENDOR=debian ;
 		elif test -f /etc/redhat-release ; then
 			VENDOR=redhat ;
 		else
 			VENDOR= ;
 		fi],
 		[ test "x${with_vendor}" != x],[
 			VENDOR="$with_vendor" ],
 		[ VENDOR= ; ]
 	)
 	AC_MSG_RESULT([$VENDOR])
 	AC_SUBST(VENDOR)
 
 	AC_MSG_CHECKING([default package type])
 	case "$VENDOR" in
 		alpine|arch|artix|gentoo|lunar|slackware)
 			DEFAULT_PACKAGE=tgz  ;;
 		debian|ubuntu)
 			DEFAULT_PACKAGE=deb  ;;
 		freebsd)
 			DEFAULT_PACKAGE=pkg  ;;
 		*)
 		# fedora|openeuler|redhat|sles|toss
 			DEFAULT_PACKAGE=rpm  ;;
 	esac
 	AC_MSG_RESULT([$DEFAULT_PACKAGE])
 	AC_SUBST(DEFAULT_PACKAGE)
 
 	AC_MSG_CHECKING([default init directory])
 	case "$VENDOR" in
 		freebsd)    initdir=$sysconfdir/rc.d  ;;
 		*)          initdir=$sysconfdir/init.d;;
 	esac
 	AC_MSG_RESULT([$initdir])
 	AC_SUBST(initdir)
 
 	AC_MSG_CHECKING([default shell])
 	case "$VENDOR" in
 		alpine|gentoo)	DEFAULT_INIT_SHELL=/sbin/openrc-run
 				IS_SYSV_RC=false	;;
 		artix)		DEFAULT_INIT_SHELL=/usr/bin/openrc-run
 				IS_SYSV_RC=false	;;
 		*)		DEFAULT_INIT_SHELL=/bin/sh
 				IS_SYSV_RC=true		;;
 	esac
 
 	AC_MSG_RESULT([$DEFAULT_INIT_SHELL])
 	AC_SUBST(DEFAULT_INIT_SHELL)
 	AC_SUBST(IS_SYSV_RC)
 
 	AC_MSG_CHECKING([default nfs server init script])
 	AS_IF([test "$VENDOR" = "debian"],
 		[DEFAULT_INIT_NFS_SERVER="nfs-kernel-server"],
 		[DEFAULT_INIT_NFS_SERVER="nfs"]
 	)
 	AC_MSG_RESULT([$DEFAULT_INIT_NFS_SERVER])
 	AC_SUBST(DEFAULT_INIT_NFS_SERVER)
 
 	AC_MSG_CHECKING([default init config directory])
 	case "$VENDOR" in
 		alpine|artix|gentoo)
 			initconfdir=/etc/conf.d
 			;;
 		fedora|openeuler|redhat|sles|toss)
 			initconfdir=/etc/sysconfig
 			;;
 		freebsd)
 			initconfdir=$sysconfdir/rc.conf.d
 			;;
 		*)
 		# debian|ubuntu
 			initconfdir=/etc/default
 			;;
 	esac
 	AC_MSG_RESULT([$initconfdir])
 	AC_SUBST(initconfdir)
 
 	AC_MSG_CHECKING([whether initramfs-tools is available])
 	if test -d /usr/share/initramfs-tools ; then
 		RPM_DEFINE_INITRAMFS='--define "_initramfs 1"'
 		AC_MSG_RESULT([yes])
 	else
 		RPM_DEFINE_INITRAMFS=''
 		AC_MSG_RESULT([no])
 	fi
 	AC_SUBST(RPM_DEFINE_INITRAMFS)
 
 	AC_MSG_CHECKING([default bash completion directory])
 	case "$VENDOR" in
 		alpine|arch|artix|debian|gentoo|ubuntu)
 			bashcompletiondir=/usr/share/bash-completion/completions
 			;;
 		freebsd)
 			bashcompletiondir=$sysconfdir/bash_completion.d
 			;;
 		*)
 			bashcompletiondir=/etc/bash_completion.d
 			;;
 	esac
 	AC_MSG_RESULT([$bashcompletiondir])
 	AC_SUBST(bashcompletiondir)
 
 ])
 
 dnl #
 dnl # Default ZFS package configuration
 dnl #
 AC_DEFUN([ZFS_AC_PACKAGE], [
 	ZFS_AC_DEFAULT_PACKAGE
 	AS_IF([test x$VENDOR != xfreebsd], [
 		ZFS_AC_RPM
 		ZFS_AC_DPKG
 		ZFS_AC_ALIEN
 	])
 ])
diff --git a/lib/libspl/Makefile.am b/lib/libspl/Makefile.am
index 6640ecd582a7..0fd907d3011e 100644
--- a/lib/libspl/Makefile.am
+++ b/lib/libspl/Makefile.am
@@ -1,53 +1,56 @@
 include $(srcdir)/%D%/include/Makefile.am
 
 libspl_assert_la_CFLAGS = $(AM_CFLAGS) $(LIBRARY_CFLAGS) $(LIBUNWIND_CFLAGS)
 libspl_la_CFLAGS        = $(libspl_assert_la_CFLAGS)
+if TARGET_CPU_I386
+libspl_la_CFLAGS        += $(NO_ATOMIC_ALIGNMENT)
+endif
 
 noinst_LTLIBRARIES += libspl_assert.la libspl.la
 CPPCHECKTARGETS    += libspl_assert.la libspl.la
 
 libspl_assert_la_SOURCES = \
 	%D%/assert.c \
 	%D%/backtrace.c
 
 libspl_la_SOURCES = \
 	%D%/libspl_impl.h \
 	%D%/atomic.c \
 	%D%/getexecname.c \
 	%D%/list.c \
 	%D%/mkdirp.c \
 	%D%/page.c \
 	%D%/strlcat.c \
 	%D%/strlcpy.c \
 	%D%/timestamp.c \
 	%D%/tunables.c \
 	%D%/include/sys/list.h \
 	%D%/include/sys/list_impl.h
 
 if BUILD_LINUX
 libspl_la_SOURCES += \
 	%D%/os/linux/getexecname.c \
 	%D%/os/linux/gethostid.c \
 	%D%/os/linux/getmntany.c \
 	%D%/os/linux/zone.c
 endif
 
 if BUILD_FREEBSD
 libspl_la_SOURCES += \
 	%D%/os/freebsd/getexecname.c \
 	%D%/os/freebsd/gethostid.c \
 	%D%/os/freebsd/getmntany.c \
 	%D%/os/freebsd/mnttab.c \
 	%D%/os/freebsd/zone.c
 endif
 
 libspl_la_LIBADD = \
 	libspl_assert.la
 
 libspl_la_LIBADD += $(LIBATOMIC_LIBS) $(LIBCLOCK_GETTIME)
 
 libspl_assert_la_LIBADD = $(BACKTRACE_LIBS) $(LIBUNWIND_LIBS)
 
 if BUILD_FREEBSD
 libspl_assert_la_LIBADD += -lpthread
 endif